Bidirectional Python bridge + 4 integration libs + harmonic ML pipeline

Three additions, all building on the py_* foundation:

1. Python ↔ OMC callbacks (py_callback)

   `py_callback("omc_fn_name")` returns a Python callable that
   wraps the OMC function. Python code can then invoke it like
   any other PyCallable — `df.apply(omc_fn)`, `np.vectorize(omc_fn)`,
   pandas/sklearn/torch hooks all work.

   Architecture: thread_local INTERP_PTR (raw pointer) is set by
   call_function / vm_call_builtin BEFORE invoking a host_builtin
   handler, cleared on return. The OmcCallback pyclass uses
   `with_active_interp(|interp| interp.call_function_with_values(...))`
   to dispatch back into the live interpreter. SAFETY contract
   documented inline; valid only inside a host call (which is the
   only time you'd be running OMC code that created the callback).

   `null` / `true` / `false` as expression-position literals
   landed alongside (both engines) — sklearn.fit(model, X, y)
   needed to pass `null` for unsupervised cases, and the parser
   was treating them as undefined variables.

2. Four new OMC integration libraries (written in OMC, not Rust)

   * examples/lib/requests.omc  — get/post/put/delete, json, headers,
     ok-test, fetch_json/fetch_text helpers. ~50 lines.
   * examples/lib/sqlite.omc    — connect/execute/query/commit, plus
     execute_with for parameter binding, query_one, tables() for
     schema introspection. Real in-memory SQL from OMC. ~80 lines.
   * examples/lib/sklearn.omc   — KMeans, LinearRegression,
     Logistic, RandomForest{Classifier,Regressor}, train_test_split
     (with kwargs!), StandardScaler, accuracy/r2/confusion_matrix,
     load_iris/wine/breast_cancer datasets. ~110 lines.
   * examples/lib/torch.omc     — tensor/zeros/ones/randn,
     add/sub/mul/matmul, nn.Linear, SGD/Adam optimizers, MSE loss,
     backward(). ~80 lines. (Pattern demo; torch is a heavy install.)

   Total: ~320 lines of OMC giving access to four major Python
   ecosystems. Same pattern user can fork for their own libs.

3. py_call_kw / py_call_fn_kw

   sklearn (and many Python APIs) distinguish positional from
   keyword args. `train_test_split(X, y, test_size=0.3)` was
   passing 0.3 as a third positional array → "Input should have
   at least 1 dimension" error. Added kwargs variants that take
   an OMC dict as the kwargs map. Both engines.

4. examples/datascience/harmonic_ml.omc — the end-to-end pipeline

   Loads sklearn wine dataset (178 samples, 13 features). Engineers
   a new harmonic_signature feature (sum of harmony_value across
   each row). Trains baseline RF + augmented RF. Demonstrates
   Python→OMC callback by registering harmonic_signature_at as a
   Python callable and using numpy.vectorize to apply it across
   all 178 sample indices.

   Both classifiers reached 100% on wine (RF is robust enough that
   the harmonic feature wasn't load-bearing on this easy dataset);
   the pipeline mechanics are what matters — OMC ↔ Python ↔ OMC,
   real ML, real data, no Rust needed for any of it.

Smoke tests: requests fetched github zen API, sqlite stored and
queried 3 rows correctly, sklearn trained RF on iris with 93.3%
accuracy, py_callback let numpy.vectorize call OMC's harmony_score
across an 11-element array.

43/43 functional examples produce identical output under tree-walk
and VM. 92/92 unit tests pass.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: RandomCoder-lab

examples/datascience/harmonic_ml.omc

@@ -0,0 +1,136 @@
+# =============================================================================
+# Harmonic ML pipeline: OMC + scikit-learn end-to-end
+# =============================================================================
+# The full story:
+#   1. Load a real classification dataset (sklearn's wine, 178 samples)
+#   2. ENGINEER NEW HARMONIC FEATURES with an OMC-only operation
+#      (harmony_value of each feature — a real number not in the
+#      original Python ecosystem)
+#   3. Train a classifier on (original + harmonic) features
+#   4. Compare to baseline (original features only)
+#   5. Use a Python ↔ OMC callback to score each sample's "harmonic
+#      signature" via numpy.vectorize
+#
+# This is the harmonic preprocessing pipeline. Replace step 2 with
+# any OMC-distinctive transform (attractor partition, HIM ranking,
+# fold-and-mod) and you have a model that's measurably aware of
+# Fibonacci structure in the input — something no native Python
+# library exposes as a primitive.
+#
+# Run:
+#   PYO3_USE_ABI3_FORWARD_COMPATIBILITY=1 cargo build --release \
+#       --bin omnimcode-standalone --features python-embed
+#   OMC_PYTHON=1 ./target/release/omnimcode-standalone \
+#       examples/datascience/harmonic_ml.omc
+# =============================================================================
+
+import "examples/lib/sklearn.omc" as sk;
+import "examples/lib/np.omc" as np;
+
+println("=== Harmonic ML pipeline (OMC + scikit-learn) ===");
+println("");
+
+# ---- 1. Load wine dataset --------------------------------------------------
+
+h wine = sk.load_wine();
+h X_orig = arr_get(wine, 0);
+h y = arr_get(wine, 1);
+println(concat_many("loaded sklearn wine: ", arr_len(X_orig), " samples, ",
+    arr_len(arr_get(X_orig, 0)), " features"));
+println("");
+
+# ---- 2. Harmonic feature engineering ---------------------------------------
+# For each row, compute one new feature: the SUM of harmony_values across
+# the original features. This is a single scalar that captures "how
+# Fibonacci-aligned is this sample's feature vector overall." Cheap to
+# compute, OMC-distinctive, completely absent from the sklearn pipeline.
+
+fn harmonic_signature(row) {
+    # row is an OMC array of 13 floats. Convert each to nearest int and
+    # sum the harmony_value scores.
+    h sum = 0.0;
+    h i = 0;
+    while i < arr_len(row) {
+        h v = to_int(arr_get(row, i) * 100);   # scale into integer space
+        sum = sum + harmony_value(v);
+        i = i + 1;
+    }
+    return sum;
+}
+
+# Build the augmented feature matrix: each row = original + 1 harmonic feature.
+fn augment(matrix) {
+    h out = [];
+    h i = 0;
+    while i < arr_len(matrix) {
+        h row = arr_get(matrix, i);
+        h h_score = harmonic_signature(row);
+        h new_row = arr_concat(row, [h_score]);
+        arr_push(out, new_row);
+        i = i + 1;
+    }
+    return out;
+}
+
+h t0 = now_ms();
+h X_aug = augment(X_orig);
+h t1 = now_ms();
+println(concat_many("augmented features in ", t1 - t0,
+    " ms (added 1 harmonic_signature column)"));
+println("");
+
+# ---- 3a. Baseline classifier on original features -------------------------
+
+h split_o = sk.train_test_split(X_orig, y, 0.3);
+h Xo_train = arr_get(split_o, 0);
+h Xo_test  = arr_get(split_o, 1);
+h yo_train = arr_get(split_o, 2);
+h yo_test  = arr_get(split_o, 3);
+
+h model_o = sk.random_forest_classifier(50);
+sk.fit(model_o, Xo_train, yo_train);
+h preds_o = sk.predict(model_o, Xo_test);
+h acc_o = sk.accuracy_score(yo_test, preds_o);
+println(concat_many("baseline RF (13 features):    accuracy = ", acc_o));
+
+# ---- 3b. Augmented classifier on (original + harmonic) features ----------
+
+h split_a = sk.train_test_split(X_aug, y, 0.3);
+h Xa_train = arr_get(split_a, 0);
+h Xa_test  = arr_get(split_a, 1);
+h ya_train = arr_get(split_a, 2);
+h ya_test  = arr_get(split_a, 3);
+
+h model_a = sk.random_forest_classifier(50);
+sk.fit(model_a, Xa_train, ya_train);
+h preds_a = sk.predict(model_a, Xa_test);
+h acc_a = sk.accuracy_score(ya_test, preds_a);
+println(concat_many("with harmonic feature (14):   accuracy = ", acc_a));
+println("");
+
+# ---- 4. Bonus: OMC callback driven by numpy.vectorize ---------------------
+# Bind harmonic_signature to a Python callable, then have numpy apply
+# it across a 1-D array of indices to compute the signature for every
+# sample. Demonstrates Python → OMC dispatch at scale.
+
+fn harmonic_signature_at(idx) {
+    return harmonic_signature(arr_get(X_orig, idx));
+}
+
+h cb = py_callback("harmonic_signature_at");
+h np_h = np._np();
+h vec = py_call(np_h, "vectorize", [cb]);
+
+# Build index range 0..nsamples in numpy and vectorize-apply.
+h idx_range = np.arange(arr_len(X_orig));
+h all_sigs = py_call_fn(vec, [idx_range]);
+
+println(concat_many("harmonic signatures computed via Python→OMC callback (",
+    arr_len(all_sigs), " samples)"));
+println(concat_many("  min: ", np.np_min(all_sigs)));
+println(concat_many("  max: ", np.np_max(all_sigs)));
+println(concat_many("  mean: ", np.mean(all_sigs)));
+println(concat_many("  std:  ", np.std(all_sigs)));
+
+println("");
+println("=== Done ===");

examples/lib/requests.omc

@@ -0,0 +1,64 @@
+# =============================================================================
+# requests bridge for OMC — HTTP in 30 lines
+# =============================================================================
+# Wraps python's `requests` library. OMC programs gain real HTTP:
+# fetch APIs, post JSON, scrape pages, anything you'd do in Python.
+#
+# Usage:
+#   import "examples/lib/requests.omc" as r;
+#   h resp = r.get("https://api.github.com/zen");
+#   println(r.text(resp));
+# =============================================================================
+
+h _RQ_HANDLE = 0;
+
+fn _rq() {
+    if _RQ_HANDLE == 0 {
+        _RQ_HANDLE = py_import("requests");
+    }
+    return _RQ_HANDLE;
+}
+
+# ---- Verbs (return Response handles) -------------------------------------
+
+fn get(url)              { return py_call(_rq(), "get",    [url]); }
+fn post(url, data)       { return py_call(_rq(), "post",   [url, data]); }
+fn put(url, data)        { return py_call(_rq(), "put",    [url, data]); }
+fn delete(url)           { return py_call(_rq(), "delete", [url]); }
+fn head(url)             { return py_call(_rq(), "head",   [url]); }
+
+# ---- Response inspection -------------------------------------------------
+
+fn status(resp)          { return py_get(resp, "status_code"); }
+fn text(resp)            { return py_get(resp, "text"); }
+fn json(resp)            { return py_call(resp, "json", []); }
+fn headers(resp)         { return py_get(resp, "headers"); }
+fn url_of(resp)          { return py_get(resp, "url"); }
+fn ok(resp) {
+    h s = status(resp);
+    if s >= 200 {
+        if s < 300 {
+            return 1;
+        }
+    }
+    return 0;
+}
+
+# ---- Convenience: one-line GET-and-parse-JSON ----------------------------
+# Returns the parsed JSON as an OMC dict/array, or null on non-200.
+fn fetch_json(url) {
+    h resp = get(url);
+    if ok(resp) == 1 {
+        return json(resp);
+    }
+    return null;
+}
+
+# Returns response text or null.
+fn fetch_text(url) {
+    h resp = get(url);
+    if ok(resp) == 1 {
+        return text(resp);
+    }
+    return null;
+}

examples/lib/sklearn.omc

@@ -0,0 +1,137 @@
+# =============================================================================
+# scikit-learn bridge for OMC — classical ML
+# =============================================================================
+# Wraps the most common scikit-learn estimators. Pattern: each fn
+# returns a fitted-or-untrained MODEL HANDLE; OMC code calls .fit and
+# .predict via py_call. Lazy module imports per submodule.
+#
+# Usage:
+#   import "examples/lib/sklearn.omc" as sk;
+#   h X = [[1, 2], [3, 4], [5, 6]];
+#   h y = [0, 1, 1];
+#   h model = sk.kmeans(2);
+#   sk.fit(model, X, y);
+#   h preds = sk.predict(model, X);
+# =============================================================================
+
+h _CLUSTER     = 0;
+h _LINEAR      = 0;
+h _ENSEMBLE    = 0;
+h _MODEL_SEL   = 0;
+h _PREPROC     = 0;
+h _METRICS     = 0;
+
+fn _cluster()    { if _CLUSTER == 0    { _CLUSTER    = py_import("sklearn.cluster"); }     return _CLUSTER; }
+fn _linear()     { if _LINEAR == 0     { _LINEAR     = py_import("sklearn.linear_model"); } return _LINEAR; }
+fn _ensemble()   { if _ENSEMBLE == 0   { _ENSEMBLE   = py_import("sklearn.ensemble"); }     return _ENSEMBLE; }
+fn _model_sel()  { if _MODEL_SEL == 0  { _MODEL_SEL  = py_import("sklearn.model_selection"); } return _MODEL_SEL; }
+fn _preproc()    { if _PREPROC == 0    { _PREPROC    = py_import("sklearn.preprocessing"); } return _PREPROC; }
+fn _metrics()    { if _METRICS == 0    { _METRICS    = py_import("sklearn.metrics"); }       return _METRICS; }
+
+# ---- Models (constructors return untrained model handle) -----------------
+
+fn kmeans(n_clusters) {
+    h cls = py_get(_cluster(), "KMeans");
+    return py_call_fn(cls, [n_clusters]);
+}
+
+fn linear_regression() {
+    h cls = py_get(_linear(), "LinearRegression");
+    return py_call_fn(cls, []);
+}
+
+fn logistic_regression() {
+    h cls = py_get(_linear(), "LogisticRegression");
+    return py_call_fn(cls, []);
+}
+
+fn random_forest_classifier(n_estimators) {
+    h cls = py_get(_ensemble(), "RandomForestClassifier");
+    return py_call_fn(cls, [n_estimators]);
+}
+
+fn random_forest_regressor(n_estimators) {
+    h cls = py_get(_ensemble(), "RandomForestRegressor");
+    return py_call_fn(cls, [n_estimators]);
+}
+
+# ---- Universal fit/predict surface ---------------------------------------
+# Every sklearn estimator has .fit(X, y) and .predict(X). Some (KMeans,
+# clustering) are unsupervised — pass null for y and we'll skip it.
+
+fn fit(model, X, y) {
+    if y == null {
+        py_call(model, "fit", [X]);
+    } else {
+        py_call(model, "fit", [X, y]);
+    }
+    return model;
+}
+
+fn predict(model, X) {
+    return py_call(model, "predict", [X]);
+}
+
+fn score(model, X, y) {
+    return py_call(model, "score", [X, y]);
+}
+
+# ---- Train/test split ----------------------------------------------------
+# Returns [X_train, X_test, y_train, y_test] as OMC arrays.
+# test_size is a kwarg in sklearn's API — passing it positionally
+# would make it a third array. py_call_fn_kw handles the split.
+fn train_test_split(X, y, test_size) {
+    h tts = py_get(_model_sel(), "train_test_split");
+    return py_call_fn_kw(tts, [X, y], {"test_size": test_size});
+}
+
+# ---- Preprocessing -------------------------------------------------------
+
+fn standard_scaler() {
+    h cls = py_get(_preproc(), "StandardScaler");
+    return py_call_fn(cls, []);
+}
+
+fn fit_transform(scaler, X) {
+    return py_call(scaler, "fit_transform", [X]);
+}
+
+fn transform(scaler, X) {
+    return py_call(scaler, "transform", [X]);
+}
+
+# ---- Metrics --------------------------------------------------------------
+
+fn accuracy_score(y_true, y_pred) {
+    return py_call(_metrics(), "accuracy_score", [y_true, y_pred]);
+}
+
+fn r2_score(y_true, y_pred) {
+    return py_call(_metrics(), "r2_score", [y_true, y_pred]);
+}
+
+fn confusion_matrix(y_true, y_pred) {
+    return py_call(_metrics(), "confusion_matrix", [y_true, y_pred]);
+}
+
+# ---- Built-in datasets (handy for demos) --------------------------------
+# Each load_* returns a Bunch; we extract data + target as OMC arrays.
+
+fn _datasets() { return py_import("sklearn.datasets"); }
+
+fn load_iris() {
+    # sklearn returns a Bunch — dict subclass — so py_to_omc auto-
+    # converts to an OMC dict. Use dict_get, not py_get.
+    h ds = py_call(_datasets(), "load_iris", []);
+    return [dict_get(ds, "data"), dict_get(ds, "target")];
+}
+
+fn load_wine() {
+    h ds = py_call(_datasets(), "load_wine", []);
+    return [dict_get(ds, "data"), dict_get(ds, "target")];
+}
+
+fn load_breast_cancer() {
+    h ds = py_call(_datasets(), "load_breast_cancer", []);
+    return [dict_get(ds, "data"), dict_get(ds, "target")];
+}