libcodey coverage - 0.55%

Files
Source

// [[Rcpp::depends(Rcpp)]]
// [[Rcpp::plugins(cpp17)]]
#include <Rcpp.h>
#include <nlohmann/json.hpp>
#include "codey/codey.hpp"

// R usage pattern:
//   codebook <- codey_codebook_add("[]", "collaboration", "Working together")
//   codes    <- codey_pattern_add("[]", codebook, "collaboration", "\\bcollabor")
//   ratings  <- jsonlite::fromJSON(codey_apply_codes(texts_json, codes))
//   id       <- codey_sample_next(pos_ids_json, neg_ids_json, n_pos, n_neg, seed)

using namespace Rcpp;

static List vr_to_list(const codey::ValidationResult& r) {
    std::vector<std::string> field, message;
    for (const auto& e : r.errors) {
        field.push_back(e.field);
        message.push_back(e.message);
    }
    return List::create(
        Named("valid")  = r.valid,
        Named("errors") = DataFrame::create(Named("field")   = field,
                                             Named("message") = message)
    );
}

//' Validate a datafile JSON array and text column name
//' @param rows_json JSON array of row objects
//' @param text_col  Name of the text column
//' @return List with \code{valid} (bool) and \code{errors} (data frame)
//' @export
// [[Rcpp::export]]
List codey_validate_datafile(const std::string& rows_json,
                              const std::string& text_col) {
    return vr_to_list(codey::validate_datafile(rows_json, text_col));
}

//' Validate codebook + codes structure and cross-references
//' @param codebook_json JSON array of \code{\{code, definition\}}
//' @param codes_json    JSON array of \code{\{code, patterns:[]\}}
//' @return List with \code{valid} and \code{errors}
//' @export
// [[Rcpp::export]]
List codey_validate_config(const std::string& codebook_json,
                            const std::string& codes_json) {
    return vr_to_list(codey::validate_config(codebook_json, codes_json));
}

//' Validate a code name; returns "" if valid, error message otherwise
//' @export
// [[Rcpp::export]]
std::string codey_validate_code_name(const std::string& name) {
    return codey::validate_code_name(name);
}

//' Validate a PCRE2 pattern; returns "" if valid, error message otherwise
//' @export
// [[Rcpp::export]]
std::string codey_validate_pattern(const std::string& pattern) {
    return codey::validate_pattern(pattern);
}

//' Add or update a code in the codebook
//' @param codebook_json JSON array of \code{\{code, definition\}} (use "[]" to start)
//' @param code          Code name
//' @param definition    Code definition
//' @return Updated codebook JSON string
//' @export
// [[Rcpp::export]]
std::string codey_codebook_add(const std::string& codebook_json,
                                const std::string& code,
                                const std::string& definition) {
    return codey::codebook_add(codebook_json, code, definition);
}

//' Remove a code from the codebook, cascading to its patterns
//' @param codebook_json JSON array of \code{\{code, definition\}}
//' @param codes_json    JSON array of \code{\{code, patterns:[]\}}
//' @param code          Code to remove
//' @return Named list with \code{codebook} and \code{codes} JSON strings
//' @export
// [[Rcpp::export]]
List codey_codebook_remove(const std::string& codebook_json,
                            const std::string& codes_json,
                            const std::string& code) {
    auto result_json = codey::codebook_remove(codebook_json, codes_json, code);
    auto j = nlohmann::json::parse(result_json);
    return List::create(Named("codebook") = j["codebook"].dump(),
                        Named("codes")    = j["codes"].dump());
}

//' Add a PCRE2 pattern for a code
//' @param codes_json    JSON array of \code{\{code, patterns:[]\}} (use "[]" to start)
//' @param codebook_json JSON array — used to verify code exists
//' @param code          Code name
//' @param pattern       PCRE2 regex pattern
//' @return Updated codes JSON string
//' @export
// [[Rcpp::export]]
std::string codey_pattern_add(const std::string& codes_json,
                               const std::string& codebook_json,
                               const std::string& code,
                               const std::string& pattern) {
    return codey::pattern_add(codes_json, codebook_json, code, pattern);
}

//' Remove a pattern from a code
//' @export
// [[Rcpp::export]]
std::string codey_pattern_remove(const std::string& codes_json,
                                  const std::string& code,
                                  const std::string& pattern) {
    return codey::pattern_remove(codes_json, code, pattern);
}

//' Apply all codes to all texts using PCRE2
//' @param texts_json JSON array of text strings (one per row)
//' @param codes_json JSON array of \code{\{code, patterns:[]\}}
//' @return JSON array of \code{\{code, values:[0|1,...]\}}
//' @export
// [[Rcpp::export]]
std::string codey_apply_codes(const std::string& texts_json,
                               const std::string& codes_json) {
    return codey::apply_codes(texts_json, codes_json);
}

//' Select the next row ID to present for human rating (stratified)
//' @param unrated_pos_json JSON int array — IDs auto-coded positive, not yet rated
//' @param unrated_neg_json JSON int array — IDs auto-coded negative, not yet rated
//' @param n_shown_positive Count of positive-coded rows already shown this session
//' @param n_shown_negative Count of negative-coded rows already shown this session
//' @param seed             Integer seed; advance per call for reproducible sequences
//' @return Row ID, or -1 if none remain
//' @export
// [[Rcpp::export]]
int codey_sample_next(const std::string& unrated_pos_json,
                       const std::string& unrated_neg_json,
                       int n_shown_positive,
                       int n_shown_negative,
                       int seed) {
    return codey::sample_next(unrated_pos_json, unrated_neg_json,
                               n_shown_positive, n_shown_negative, seed);
}

#include "codey/codey.hpp"
#include <nlohmann/json.hpp>
#include <cstdlib>

using json = nlohmann::json;

namespace codey {

// Stratified sampling: maintain proportional representation of positive and
// negative auto-coded rows across the human rating session.
//
// Strategy:
//   target positive rate = pos_pool / (pos_pool + neg_pool)
//   current shown rate   = n_shown_positive / (n_shown_positive + n_shown_negative)
//   if current < target → draw from positive pool (underrepresented)
//   else                → draw from negative pool
//   within the chosen pool, pick deterministically using seed % pool.size()
//
// This ensures the human rater sees a statistically representative sample
// without requiring stored state between calls — seed advances are the
// caller's responsibility.

int sample_next(const std::string& unrated_pos_json,
                const std::string& unrated_neg_json,
                int n_shown_positive,
                int n_shown_negative,
                int seed) {
    const json pos = json::parse(unrated_pos_json);
    const json neg = json::parse(unrated_neg_json);

    if (pos.empty() && neg.empty()) return -1;

    const double total_pos    = static_cast<double>(pos.size() + n_shown_positive);
    const double total_neg    = static_cast<double>(neg.size() + n_shown_negative);
    const double total        = total_pos + total_neg;
    const double target_rate  = (total > 0) ? total_pos / total : 0.5;
    const double shown_total  = static_cast<double>(n_shown_positive + n_shown_negative);
    const double current_rate = (shown_total > 0)
        ? static_cast<double>(n_shown_positive) / shown_total
        : -1.0; // force positive pool on first draw

    const bool draw_positive = !pos.empty() &&
        (neg.empty() || current_rate < target_rate);

    const json& pool = draw_positive ? pos : neg;
    const int   idx  = static_cast<int>(static_cast<unsigned>(seed) % pool.size());
    return pool[idx].get<int>();
}

} // namespace codey

#define PCRE2_CODE_UNIT_WIDTH 8
#include "codey/codey.hpp"
#include <nlohmann/json.hpp>
#include <pcre2.h>
#include <algorithm>
#include <cctype>

using json = nlohmann::json;

namespace codey {

std::string validate_code_name(const std::string& name) {
    if (name.empty())
        return "code name must not be empty";
    if (!std::isalpha(static_cast<unsigned char>(name[0])))
        return "code name must start with a letter";
    for (char c : name)
        if (!std::isalnum(static_cast<unsigned char>(c)) && c != '_' && c != '.')
            return "code name may only contain letters, digits, underscores, and dots";
    if (name.length() > 64)
        return "code name must be 64 characters or fewer";
    return "";
}

std::string validate_pattern(const std::string& pattern) {
    int error_code;
    PCRE2_SIZE error_offset;
    pcre2_code* re = pcre2_compile(
        reinterpret_cast<PCRE2_SPTR>(pattern.c_str()),
        PCRE2_ZERO_TERMINATED,
        PCRE2_CASELESS | PCRE2_UTF,
        &error_code, &error_offset, nullptr);
    if (!re) {
        PCRE2_UCHAR buf[256];
        pcre2_get_error_message(error_code, buf, sizeof(buf));
        return std::string(reinterpret_cast<char*>(buf));
    }
    pcre2_code_free(re);
    return "";
}

ValidationResult validate_datafile(const std::string& rows_json,
                                    const std::string& text_col) {
    ValidationResult r;
    json j;
    try { j = json::parse(rows_json); }
    catch (...) {
        r.valid = false;
        r.errors.push_back({"rows_json", "invalid JSON"});
        return r;
    }
    if (!j.is_array() || j.empty()) {
        r.valid = false;
        r.errors.push_back({"rows_json", "must be a non-empty array"});
        return r;
    }
    if (text_col.empty()) {
        r.valid = false;
        r.errors.push_back({"text_col", "must not be empty"});
    }
    if (!j[0].contains(text_col)) {
        r.valid = false;
        r.errors.push_back({"text_col", "column '" + text_col + "' not found in rows"});
    }
    return r;
}

ValidationResult validate_config(const std::string& codebook_json,
                                  const std::string& codes_json) {
    ValidationResult r;

    json cb, codes;
    try { cb = json::parse(codebook_json); }
    catch (...) {
        r.valid = false;
        r.errors.push_back({"codebook_json", "invalid JSON"});
        return r;
    }
    try { codes = json::parse(codes_json); }
    catch (...) {
        r.valid = false;
        r.errors.push_back({"codes_json", "invalid JSON"});
        return r;
    }

    // Collect valid code names from codebook
    std::vector<std::string> known_codes;
    for (size_t i = 0; i < cb.size(); ++i) {
        const auto& entry = cb[i];
        if (!entry.contains("code") || !entry.contains("definition")) {
            r.valid = false;
            r.errors.push_back({"codebook[" + std::to_string(i) + "]",
                                 "missing 'code' or 'definition'"});
            continue;
        }
        std::string name = entry["code"].get<std::string>();
        auto err = validate_code_name(name);
        if (!err.empty()) {
            r.valid = false;
            r.errors.push_back({"codebook[" + std::to_string(i) + "].code", err});
        }
        if (std::find(known_codes.begin(), known_codes.end(), name) != known_codes.end()) {
            r.valid = false;
            r.errors.push_back({"codebook[" + std::to_string(i) + "].code",
                                 "duplicate code '" + name + "'"});
        }
        known_codes.push_back(name);
    }

    // Validate codes array
    for (size_t i = 0; i < codes.size(); ++i) {
        const auto& entry = codes[i];
        if (!entry.contains("code") || !entry.contains("patterns")) {
            r.valid = false;
            r.errors.push_back({"codes[" + std::to_string(i) + "]",
                                 "missing 'code' or 'patterns'"});
            continue;
        }
        std::string name = entry["code"].get<std::string>();
        if (std::find(known_codes.begin(), known_codes.end(), name) == known_codes.end()) {
            r.valid = false;
            r.errors.push_back({"codes[" + std::to_string(i) + "].code",
                                 "'" + name + "' not in codebook"});
        }
        const auto& patterns = entry["patterns"];
        for (size_t k = 0; k < patterns.size(); ++k) {
            std::string pat = patterns[k].get<std::string>();
            auto err = validate_pattern(pat);
            if (!err.empty()) {
                r.valid = false;
                r.errors.push_back({
                    "codes[" + std::to_string(i) + "].patterns[" + std::to_string(k) + "]",
                    err
                });
            }
        }
    }

    return r;
}

} // namespace codey

1		#' @useDynLib libcodey, .registration = TRUE
2		#' @importFrom Rcpp evalCpp
3		NULL
4
5		.onLoad <- function(libname, pkgname) {
6	!	invisible(NULL)
7		}

1		#include "codey/codey.hpp"
2		#include <nlohmann/json.hpp>
3		#include <stdexcept>
4
5		using json = nlohmann::json;
6
7		namespace codey {
8
9	!	std::string codebook_add(const std::string& codebook_json,
10		const std::string& code,
11		const std::string& definition) {
12	!	auto err = validate_code_name(code);
13	!	if (!err.empty()) throw std::invalid_argument("invalid code name: " + err);
14
15	!	json cb = json::parse(codebook_json);
16	!	for (auto& entry : cb) {
17	!	if (entry["code"].get<std::string>() == code) {
18	!	entry["definition"] = definition;
19	!	return cb.dump();
20		}
21		}
22	!	cb.push_back({{"code", code}, {"definition", definition}});
23	!	return cb.dump();
24		}
25
26	!	std::string codebook_remove(const std::string& codebook_json,
27		const std::string& codes_json,
28		const std::string& code) {
29	!	json cb = json::parse(codebook_json);
30	!	json codes = json::parse(codes_json);
31
32		// Remove from codebook
33	!	cb.erase(std::remove_if(cb.begin(), cb.end(),
34	!	[&](const json& e) { return e["code"].get<std::string>() == code; }),
35	!	cb.end());
36
37		// Cascade: remove from codes
38	!	codes.erase(std::remove_if(codes.begin(), codes.end(),
39	!	[&](const json& e) { return e["code"].get<std::string>() == code; }),
40	!	codes.end());
41
42	!	return json{{"codebook", cb}, {"codes", codes}}.dump();
43		}
44
45		} // namespace codey

1		// [[Rcpp::depends(Rcpp)]]
2		// [[Rcpp::plugins(cpp17)]]
3		#include <Rcpp.h>
4		#include <nlohmann/json.hpp>
5		#include "codey/codey.hpp"
6
7		// R usage pattern:
8		// codebook <- codey_codebook_add("[]", "collaboration", "Working together")
9		// codes <- codey_pattern_add("[]", codebook, "collaboration", "\\bcollabor")
10		// ratings <- jsonlite::fromJSON(codey_apply_codes(texts_json, codes))
11		// id <- codey_sample_next(pos_ids_json, neg_ids_json, n_pos, n_neg, seed)
12
13		using namespace Rcpp;
14
15	!	static List vr_to_list(const codey::ValidationResult& r) {
16	!	std::vector<std::string> field, message;
17	!	for (const auto& e : r.errors) {
18	!	field.push_back(e.field);
19	!	message.push_back(e.message);
20		}
21		return List::create(
22	!	Named("valid") = r.valid,
23	!	Named("errors") = DataFrame::create(Named("field") = field,
24	!	Named("message") = message)
25		);
26		}
27
28		//' Validate a datafile JSON array and text column name
29		//' @param rows_json JSON array of row objects
30		//' @param text_col Name of the text column
31		//' @return List with \code{valid} (bool) and \code{errors} (data frame)
32		//' @export
33		// [[Rcpp::export]]
34	!	List codey_validate_datafile(const std::string& rows_json,
35		const std::string& text_col) {
36	!	return vr_to_list(codey::validate_datafile(rows_json, text_col));
37		}
38
39		//' Validate codebook + codes structure and cross-references
40		//' @param codebook_json JSON array of \code{\{code, definition\}}
41		//' @param codes_json JSON array of \code{\{code, patterns:[]\}}
42		//' @return List with \code{valid} and \code{errors}
43		//' @export
44		// [[Rcpp::export]]
45	!	List codey_validate_config(const std::string& codebook_json,
46		const std::string& codes_json) {
47	!	return vr_to_list(codey::validate_config(codebook_json, codes_json));
48		}
49
50		//' Validate a code name; returns "" if valid, error message otherwise
51		//' @export
52		// [[Rcpp::export]]
53	17x	std::string codey_validate_code_name(const std::string& name) {
54	17x	return codey::validate_code_name(name);
55		}
56
57		//' Validate a PCRE2 pattern; returns "" if valid, error message otherwise
58		//' @export
59		// [[Rcpp::export]]
60	!	std::string codey_validate_pattern(const std::string& pattern) {
61	!	return codey::validate_pattern(pattern);
62		}
63
64		//' Add or update a code in the codebook
65		//' @param codebook_json JSON array of \code{\{code, definition\}} (use "[]" to start)
66		//' @param code Code name
67		//' @param definition Code definition
68		//' @return Updated codebook JSON string
69		//' @export
70		// [[Rcpp::export]]
71	!	std::string codey_codebook_add(const std::string& codebook_json,
72		const std::string& code,
73		const std::string& definition) {
74	!	return codey::codebook_add(codebook_json, code, definition);
75		}
76
77		//' Remove a code from the codebook, cascading to its patterns
78		//' @param codebook_json JSON array of \code{\{code, definition\}}
79		//' @param codes_json JSON array of \code{\{code, patterns:[]\}}
80		//' @param code Code to remove
81		//' @return Named list with \code{codebook} and \code{codes} JSON strings
82		//' @export
83		// [[Rcpp::export]]
84	!	List codey_codebook_remove(const std::string& codebook_json,
85		const std::string& codes_json,
86		const std::string& code) {
87	!	auto result_json = codey::codebook_remove(codebook_json, codes_json, code);
88	!	auto j = nlohmann::json::parse(result_json);
89	!	return List::create(Named("codebook") = j["codebook"].dump(),
90	!	Named("codes") = j["codes"].dump());
91		}
92
93		//' Add a PCRE2 pattern for a code
94		//' @param codes_json JSON array of \code{\{code, patterns:[]\}} (use "[]" to start)
95		//' @param codebook_json JSON array — used to verify code exists
96		//' @param code Code name
97		//' @param pattern PCRE2 regex pattern
98		//' @return Updated codes JSON string
99		//' @export
100		// [[Rcpp::export]]
101	!	std::string codey_pattern_add(const std::string& codes_json,
102		const std::string& codebook_json,
103		const std::string& code,
104		const std::string& pattern) {
105	!	return codey::pattern_add(codes_json, codebook_json, code, pattern);
106		}
107
108		//' Remove a pattern from a code
109		//' @export
110		// [[Rcpp::export]]
111	!	std::string codey_pattern_remove(const std::string& codes_json,
112		const std::string& code,
113		const std::string& pattern) {
114	!	return codey::pattern_remove(codes_json, code, pattern);
115		}
116
117		//' Apply all codes to all texts using PCRE2
118		//' @param texts_json JSON array of text strings (one per row)
119		//' @param codes_json JSON array of \code{\{code, patterns:[]\}}
120		//' @return JSON array of \code{\{code, values:[0\|1,...]\}}
121		//' @export
122		// [[Rcpp::export]]
123	!	std::string codey_apply_codes(const std::string& texts_json,
124		const std::string& codes_json) {
125	!	return codey::apply_codes(texts_json, codes_json);
126		}
127
128		//' Select the next row ID to present for human rating (stratified)
129		//' @param unrated_pos_json JSON int array — IDs auto-coded positive, not yet rated
130		//' @param unrated_neg_json JSON int array — IDs auto-coded negative, not yet rated
131		//' @param n_shown_positive Count of positive-coded rows already shown this session
132		//' @param n_shown_negative Count of negative-coded rows already shown this session
133		//' @param seed Integer seed; advance per call for reproducible sequences
134		//' @return Row ID, or -1 if none remain
135		//' @export
136		// [[Rcpp::export]]
137	!	int codey_sample_next(const std::string& unrated_pos_json,
138		const std::string& unrated_neg_json,
139		int n_shown_positive,
140		int n_shown_negative,
141		int seed) {
142	!	return codey::sample_next(unrated_pos_json, unrated_neg_json,
143	!	n_shown_positive, n_shown_negative, seed);
144		}

1		#define PCRE2_CODE_UNIT_WIDTH 8
2		#include "codey/codey.hpp"
3		#include <nlohmann/json.hpp>
4		#include <pcre2.h>
5		#include <stdexcept>
6
7		using json = nlohmann::json;
8
9		namespace codey {
10
11	!	static pcre2_code* compile_pattern(const std::string& pattern) {
12		int error_code;
13		PCRE2_SIZE error_offset;
14	!	pcre2_code* re = pcre2_compile(
15	!	reinterpret_cast<PCRE2_SPTR>(pattern.c_str()),
16		PCRE2_ZERO_TERMINATED,
17		PCRE2_CASELESS \| PCRE2_UTF,
18		&error_code, &error_offset, nullptr);
19	!	if (!re) {
20		PCRE2_UCHAR buf[256];
21	!	pcre2_get_error_message(error_code, buf, sizeof(buf));
22		throw std::runtime_error(
23	!	"PCRE2 compile error at offset " + std::to_string(error_offset) +
24	!	": " + reinterpret_cast<char*>(buf));
25		}
26	!	return re;
27		}
28
29	!	static bool match_any(const std::vector<pcre2_code*>& res, const std::string& text) {
30	!	pcre2_match_data* md = nullptr;
31	!	for (pcre2_code* re : res) {
32	!	if (!md) md = pcre2_match_data_create_from_pattern(re, nullptr);
33	!	int rc = pcre2_match(re,
34	!	reinterpret_cast<PCRE2_SPTR>(text.c_str()), text.length(),
35		0, 0, md, nullptr);
36	!	if (rc >= 0) { pcre2_match_data_free(md); return true; }
37		}
38	!	if (md) pcre2_match_data_free(md);
39	!	return false;
40		}
41
42	!	std::string apply_codes(const std::string& texts_json,
43		const std::string& codes_json) {
44	!	const json texts = json::parse(texts_json);
45	!	const json codes = json::parse(codes_json);
46	!	const int n = static_cast<int>(texts.size());
47
48		struct CompiledCode {
49		std::string name;
50		std::vector<pcre2_code*> patterns;
51		};
52
53	!	std::vector<CompiledCode> compiled;
54	!	compiled.reserve(codes.size());
55	!	for (const auto& entry : codes) {
56	!	CompiledCode cc;
57	!	cc.name = entry["code"].get<std::string>();
58	!	for (const auto& p : entry["patterns"])
59	!	cc.patterns.push_back(compile_pattern(p.get<std::string>()));
60	!	compiled.push_back(std::move(cc));
61		}
62
63	!	json result = json::array();
64	!	for (const auto& cc : compiled) {
65	!	json values = json::array();
66	!	for (int i = 0; i < n; ++i) {
67	!	const std::string text = texts[i].get<std::string>();
68	!	values.push_back(match_any(cc.patterns, text) ? 1 : 0);
69		}
70	!	result.push_back({{"code", cc.name}, {"values", values}});
71		}
72
73	!	for (auto& cc : compiled)
74	!	for (pcre2_code* re : cc.patterns) pcre2_code_free(re);
75
76	!	return result.dump();
77		}
78
79		} // namespace codey

1		#include "codey/codey.hpp"
2		#include <nlohmann/json.hpp>
3		#include <stdexcept>
4
5		using json = nlohmann::json;
6
7		namespace codey {
8
9	!	std::string pattern_add(const std::string& codes_json,
10		const std::string& codebook_json,
11		const std::string& code,
12		const std::string& pattern) {
13		// Validate pattern compiles
14	!	auto perr = validate_pattern(pattern);
15	!	if (!perr.empty()) throw std::invalid_argument("invalid pattern: " + perr);
16
17		// Validate code exists in codebook
18	!	json cb = json::parse(codebook_json);
19	!	bool found = false;
20	!	for (const auto& entry : cb)
21	!	if (entry["code"].get<std::string>() == code) { found = true; break; }
22	!	if (!found)
23	!	throw std::invalid_argument("code '" + code + "' not in codebook");
24
25	!	json codes = json::parse(codes_json);
26
27		// Find or create the entry for this code
28	!	for (auto& entry : codes) {
29	!	if (entry["code"].get<std::string>() == code) {
30		// Avoid duplicates
31	!	for (const auto& p : entry["patterns"])
32	!	if (p.get<std::string>() == pattern) return codes.dump();
33	!	entry["patterns"].push_back(pattern);
34	!	return codes.dump();
35		}
36		}
37	!	codes.push_back({{"code", code}, {"patterns", json::array({pattern})}});
38	!	return codes.dump();
39		}
40
41	!	std::string pattern_remove(const std::string& codes_json,
42		const std::string& code,
43		const std::string& pattern) {
44	!	json codes = json::parse(codes_json);
45	!	for (auto& entry : codes) {
46	!	if (entry["code"].get<std::string>() == code) {
47	!	auto& pats = entry["patterns"];
48	!	pats.erase(std::remove_if(pats.begin(), pats.end(),
49	!	[&](const json& p) { return p.get<std::string>() == pattern; }),
50	!	pats.end());
51	!	break;
52		}
53		}
54	!	return codes.dump();
55		}
56
57		} // namespace codey

1		#include "codey/codey.hpp"
2		#include <nlohmann/json.hpp>
3		#include <cstdlib>
4
5		using json = nlohmann::json;
6
7		namespace codey {
8
9		// Stratified sampling: maintain proportional representation of positive and
10		// negative auto-coded rows across the human rating session.
11		//
12		// Strategy:
13		// target positive rate = pos_pool / (pos_pool + neg_pool)
14		// current shown rate = n_shown_positive / (n_shown_positive + n_shown_negative)
15		// if current < target → draw from positive pool (underrepresented)
16		// else → draw from negative pool
17		// within the chosen pool, pick deterministically using seed % pool.size()
18		//
19		// This ensures the human rater sees a statistically representative sample
20		// without requiring stored state between calls — seed advances are the
21		// caller's responsibility.
22
23	!	int sample_next(const std::string& unrated_pos_json,
24		const std::string& unrated_neg_json,
25		int n_shown_positive,
26		int n_shown_negative,
27		int seed) {
28	!	const json pos = json::parse(unrated_pos_json);
29	!	const json neg = json::parse(unrated_neg_json);
30
31	!	if (pos.empty() && neg.empty()) return -1;
32
33	!	const double total_pos = static_cast<double>(pos.size() + n_shown_positive);
34	!	const double total_neg = static_cast<double>(neg.size() + n_shown_negative);
35	!	const double total = total_pos + total_neg;
36	!	const double target_rate = (total > 0) ? total_pos / total : 0.5;
37	!	const double shown_total = static_cast<double>(n_shown_positive + n_shown_negative);
38	!	const double current_rate = (shown_total > 0)
39	!	? static_cast<double>(n_shown_positive) / shown_total
40		: -1.0; // force positive pool on first draw
41
42	!	const bool draw_positive = !pos.empty() &&
43	!	(neg.empty() \|\| current_rate < target_rate);
44
45	!	const json& pool = draw_positive ? pos : neg;
46	!	const int idx = static_cast<int>(static_cast<unsigned>(seed) % pool.size());
47	!	return pool[idx].get<int>();
48		}
49
50		} // namespace codey

1		// __ _____ _____ _____
2		// __\| \| __\| \| \| \| JSON for Modern C++
3		// \| \| \|__ \| \| \| \| \| \| version 3.11.3
4		// \|_____\|_____\|_____\|_\|___\| https://github.com/nlohmann/json
5		//
6		// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
7		// SPDX-License-Identifier: MIT
8
9		/****************************************************************************\
10		* Note on documentation: The source files contain links to the online *
11		* documentation of the public API at https://json.nlohmann.me. This URL *
12		* contains the most recent documentation and should also be applicable to *
13		* previous versions; documentation for deprecated functions is not *
14		* removed, but marked deprecated. See "Generate documentation" section in *
15		* file docs/README.md. *
16		\****************************************************************************/
17
18		#ifndef INCLUDE_NLOHMANN_JSON_HPP_
19		#define INCLUDE_NLOHMANN_JSON_HPP_
20
21		#include <algorithm> // all_of, find, for_each
22		#include <cstddef> // nullptr_t, ptrdiff_t, size_t
23		#include <functional> // hash, less
24		#include <initializer_list> // initializer_list
25		#ifndef JSON_NO_IO
26		#include <iosfwd> // istream, ostream
27		#endif // JSON_NO_IO
28		#include <iterator> // random_access_iterator_tag
29		#include <memory> // unique_ptr
30		#include <string> // string, stoi, to_string
31		#include <utility> // declval, forward, move, pair, swap
32		#include <vector> // vector
33
34		// #include <nlohmann/adl_serializer.hpp>
35		// __ _____ _____ _____
36		// __\| \| __\| \| \| \| JSON for Modern C++
37		// \| \| \|__ \| \| \| \| \| \| version 3.11.3
38		// \|_____\|_____\|_____\|_\|___\| https://github.com/nlohmann/json
39		//
40		// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>