Name: Sewlore Synthetic Fabric CSV Validation Cases
Creator: Sewlore
Published: 2026-10-08

72 invented software-test inputs with raw CSV tokens, parser-specific expected labels and diagnostics. Use this MIT-licensed, deterministic corpus to learn CSV validation and compare regression behavior against sewlore-fabric-care 0.1.0. It contains no physical fabric observations, personal data, academic validation or machine-learning benchmark results.

These are software fixtures. Every reading and identifier is invented. Expected results describe a specific parser version; they are not independent scientific ground truth or evidence about how a real fabric behaves.

72invented test cases

26raw-string viewing columns

MITfree reuse with the notice

30 / 42core accepted / rejected

27 / 45strict accepted / rejected

0physical observations

Creator: Sewlore · Corpus version: 1.0.0-preparation · Prepared: 7 October 2026 · Data snapshot published: 8 October 2026 · Frozen parser: sewlore-fabric-care==0.1.0

Download the exact source files

Downloads below point to the unchanged, public Hugging Face snapshot, rather than a moving latest version. Choose the ten-column input file to exercise the validator, or the 26-column joined table to inspect inputs beside their labels. No account or form submission is needed.

Joined viewing table — data/cases.csv72 rows × 26 string columns. For browsing and joining labels; do not submit this table to the validator. 26,787 bytes.
Raw validator input — data/synthetic_cases.csv72 rows × 10 input columns. Preserves deliberate blank, invalid and extreme tokens. 3,114 bytes.
Case catalog — data/case_catalog.csv72 rows × 5 columns: stable IDs, corpus record numbers, intended features and synthetic markers. 3,347 bytes.
Independent per-case labels — data/expected_labels.csv72 rows × 11 columns: core and strict-policy outcomes, diagnostic counts and core percentage outputs. 6,849 bytes.
Complete per-case diagnostics — data/expected_diagnostics.jsonCore and strict-policy diagnostic arrays keyed by the 72 stable case IDs. 24,141 bytes.
Whole-corpus result — data/expected_batch_results.jsonA separate whole-file evaluation. The strict policy blocks this corpus before calculation. 9,598 bytes.

Documentation and reproduction files: DATA_DICTIONARY.md · generate.py · verify_preparation.py · build_viewer_table.py · PROVENANCE.json · README.md · LICENSE.txt

What the corpus teaches

The 18 normal cases combine six ratio and rectangle-assumption shapes with cm, mm and in. The 41 invalid-intent cases exercise missing or nonpositive numbers, invalid numeric tokens, unit mismatches and stricter submission rules. The 13 edge cases cover numeric notation, whitespace and extreme floating-point values. An intended category does not determine the parser outcome.

Evaluate each case alone, with the exact ten-column header, when comparing the supplied per-case labels. validate_csv checks the core record contract. validate_submission adds a stricter anonymous-input policy: bounded UTF-8 input, sample- identifiers with 1–6 digits, enumerated care codes and empty notes.

Three cases pass the core but fail that stricter policy: a nonconforming identifier, an unsupported care code and a nonempty synthetic note. Evaluating the whole corpus is a different operation: the core accepts 30 records with 46 diagnostic entries, while the strict policy blocks the entire file with 5 policy diagnostic entries before calculation. These are counts of software outputs, not fabric samples.

A small, literal preview

These six rows come directly from data/cases.csv. Empty percentage cells mean the core rejected that case. Long decimal outputs and tokens such as NaN are preserved as text; do not infer measurement precision from them. Scroll the table horizontally on a small screen.

Six selected records from the 72-case joined table
`case_id`	`feature`	`sample_id`	`before_length`	`after_length`	`core_status`	`policy_status`	`length_change_percent`
`case-001`	`cm:unchanged`	`sample-001`	`20`	`20`	`accepted`	`accepted`	`0`
`case-004`	`cm:two-axis-contraction`	`sample-004`	`20`	`19`	`accepted`	`accepted`	`5.0000000000000044`
`case-020`	`before_length:zero`	`sample-020`	`0`	`19`	`rejected`	`rejected`
`case-022`	`before_length:nan`	`sample-022`	`NaN`	`19`	`rejected`	`rejected`
`case-057`	`nonconforming-anonymous-id`	`case-nonconforming`	`20`	`19`	`accepted`	`rejected`	`5.0000000000000044`
`case-060`	`small-finite-readings`	`sample-060`	`1e-8`	`9e-9`	`accepted`	`accepted`	`9.9999999999999982`

Data dictionary: the 26-column viewing table

Read every column as a string. CSV quoting is ordinary CSV escaping; use a CSV reader. Numeric-looking cells may contain deliberately invalid inputs, scientific notation, blanks or surrounding whitespace. The complete source data dictionary also documents the separate input, catalog, label and JSON files.

All 26 viewing columns; stored type is string
Column	Meaning
`case_id`	Stable join key: case-001 through case-072, independent of the input sample identifier.
`csv_logical_record_number`	Original corpus record number, 2–73; record 1 is the CSV header. Stored as text.
`category`	Intended exercise: normal, invalid or edge. This intention is not a validation result.
`feature`	The particular lexical or numeric rule selected for this invented case.
`is_synthetic`	Literal true for every record. All inputs are invented.
`sample_id`	Original input identifier token. One is blank; one intentionally violates the strict sample- plus 1–6 digits rule.
`before_unit`	Original input unit token. Supported normalized codes are cm, mm and in; unsupported and whitespace tokens are included.
`after_unit`	Later input unit token. The normalized value must match before_unit; mismatches are intentional fixtures.
`before_length`	Hypothetical original length token. The parser requires a finite decimal greater than zero.
`before_width`	Hypothetical original width token, with the same numeric rule.
`after_length`	Hypothetical later length token. No physical treatment or measurement took place.
`after_width`	Hypothetical later width token. Invalid and extreme numeric tokens are retained literally.
`care_method`	Artificial parser code. Strict codes: wash, dry, wash-and-dry, rinse, steam, press, other. No treatment is claimed.
`rectangle_assumption`	yes enables hypothetical rectangle arithmetic; no or blank omits area. Invalid tokens and case normalization are tested.
`notes`	Blank except for one literal synthetic note. The core permits it; the strict policy rejects it.
`core_status`	Actual accepted or rejected result from validate_csv for this case evaluated alone.
`core_error_count`	Number of actual core diagnostic entries, serialized as text; not a count of physical samples.
`core_error_fields`	JSON-array string of actual core diagnostic field names, retaining repetitions.
`policy_status`	Actual independent accepted or rejected result from validate_submission for this case evaluated alone.
`policy_error_count`	Number of actual strict-policy diagnostic entries, serialized as text.
`policy_error_fields`	JSON-array string of actual strict-policy diagnostic field names.
`length_change_percent`	Core numeric output (1 − after_length / before_length) × 100; empty when the core rejects the case.
`width_change_percent`	Core numeric output (1 − after_width / before_width) × 100; empty when the core rejects the case.
`rectangular_area_change_percent`	Core numeric output (1 − length_ratio × width_ratio) × 100 for yes only; otherwise empty.
`core_diagnostics_json`	JSON array of complete core diagnostic objects: record_number, sample_id, field, message.
`policy_diagnostics_json`	JSON array of complete strict-policy diagnostics; unrecognized identifiers are deliberately redacted.

Unit scales used by the pinned Python parser are mm = 1, cm = 10 and in = 25.4. Before and after units must match after normalization. The corpus is structurally well-formed CSV; malformed quoting and wrong headers are outside its scope.

Read the hypothetical arithmetic correctly

Directional change (%) = (1 − after / before) × 100
Rectangular area change (%) = (1 − length_ratio × width_ratio) × 100

Positive values mean hypothetical contraction; negative values mean hypothetical expansion. Area is present only when the rectangle assumption is yes. For example, the invented 20 → 19 length and 10 → 9 width case represents 5% length change, 10% width change and 14.5% rectangular area change. The area percentage is not the sum of the two directional percentages.

Outputs preserve 17 significant digits of the pinned binary floating-point implementation. Use a documented numerical tolerance when comparing another implementation; identical binary digits are not a claim of physical accuracy.

Inspect and reproduce the software outputs

For a first inspection, download data/cases.csv and preserve its data/ folder path. This example uses only Python's standard library and performs no network requests.

import csv
import json
from collections import Counter

with open("data/cases.csv", encoding="utf-8", newline="") as handle:
    cases = list(csv.DictReader(handle))
assert len(cases) == 72
assert Counter(row["core_status"] for row in cases) == {"accepted": 30, "rejected": 42}
for row in cases:
    if row["core_status"] == "accepted" and row["policy_status"] == "rejected":
        print(row["case_id"], row["feature"], json.loads(row["policy_diagnostics_json"]))

For exact reproduction, download the six data files and the generator, verifier and join builder above into the same folder structure. Python 3.10 or newer is required. The first command downloads the public frozen wheel; the three checks then regenerate results in memory and compare the supplied files.

python -m pip download --only-binary=:all: --no-deps sewlore-fabric-care==0.1.0 --dest wheels
python generate.py --wheel wheels/sewlore_fabric_care-0.1.0-py3-none-any.whl --check
python verify_preparation.py --wheel wheels/sewlore_fabric_care-0.1.0-py3-none-any.whl
python build_viewer_table.py --check

Required wheel SHA-256:

3fda5e77c92aea891b5c4ea1f53f0bfac6f1d7bc1a3ff0003e725bf70f6f0606

Inspect the fixed software source revision or the public package 0.1.0 for the contract that produced the labels. The joined-table builder performs no relabeling and does not change input tokens.

Exact source-file SHA-256 checksums

7cee4571559635694b3d86f6ae4e2a45ae8da7f45404e485a9dd443c28eca7f3  DATA_DICTIONARY.md
679cd69b3044c64b2d6453021d4273c9a1246c20415f8780069ca35c939458f0  LICENSE.txt
0394b2f3ab1fe6e79ac866df2ae09a2bb1f6e0b21672056572340abd36c16547  PROVENANCE.json
1adc3a3f53d7edcb30ed234f9f52d4df757d8198847f38961970216da5dce01b  generate.py
d0bcb5206f2e5c34331c1dffb4b63b29556178b3edde5e06bd95a16f418d85fc  verify_preparation.py
43de8b8c71bf3181e0b009fd4457265e96bfd0d6697f401fb5dd576236d227f2  data/synthetic_cases.csv
11b36ac8d4c067c2ba8bacff4336fc9f2147c1cda9120eb534c5c7f8282b5e6e  data/expected_labels.csv
4c25daa44eacb78c8904bd26159f4e754645fb254adfab51b9b98382006b34b7  data/case_catalog.csv
e61691822045490f35271a79fd23a5f59f7af0eab54904c55653674454a11293  data/expected_diagnostics.json
233f82b0e67c570def0f0fa9b22169495422e12acc12f562b502aed2bb891750  data/expected_batch_results.json
ff5fec7a25a28919d4eaa7bbeafdd0a4985ee3d155f3dbce125fe7b693f783a2  README.md
7f0a9e648b4488a9c7be604e8d1e18c2f8fbcf07ebc560a9407747cc12054990  build_viewer_table.py
47e6a381d73e1cc32a6dd2b0689c6cec04f8cad6e0163b1be2c9bc4b41d0677e  data/cases.csv

Provenance and limitations

Sewlore prepared explicit deterministic case definitions with AI assistance. Labels were captured by executing the SHA-256-pinned public wheel independently for each case. The same original inputs, expected outputs, documentation and license are available in the public snapshot a4d965dc9c561c4c8ceccaadf3e8647f628a25f7.

The original PROVENANCE.json retains its historical prepared-not-published status, because it was written before publication. It documents preparation, not the current hosting status. The downloadable corpus is unchanged from that reviewed preparation; this page explains its already published snapshot.

No physical fabric, garments, washing observations, photographs or personal data were collected. No model was trained or evaluated, no cases were held out and no academic paper, peer review, institutional affiliation or individual researcher contribution is claimed. The test split is a software-fixture label, not a machine-learning train/test design.

This small, explicitly selected corpus does not estimate real-world error rates or establish textile suitability, care advice, garment fit or general validator quality. Structural CSV failures, byte-limit and row-limit tests are outside this set. Treat version-specific messages as implementation output, not universal rules.

Reuse, attribution and related learning

The original MIT notice must accompany copies or substantial portions. Sewlore names and branding remain the property of their owner; the license does not grant trademark ownership or imply endorsement.

Read the unchanged MIT license and notice

MIT License

Copyright (c) 2026 Sewlore

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

Sewlore names and branding remain the property of their respective owner. This
licence does not grant trademark ownership or imply endorsement.

A practical attribution is: Sewlore, Synthetic Fabric CSV Validation Cases, corpus version 1.0.0-preparation, snapshot a4d965dc9c561c4c8ceccaadf3e8647f628a25f7, frozen software 0.1.0, MIT. Include a link to the original dataset and retain the license notice.

The fabric measurement methods guide supplies record-keeping context. The public validator lesson shows how to review accepted records and corrections. Neither is evidence that a real fabric experiment took place.

Synthetic Fabric CSV Validation Cases