tranfi 0.1.2 → 0.2.1

package/csrc/op_source_name.c

@@ -0,0 +1,120 @@
+/*
+ * op_source_name.c -- Append the current host-provided source name.
+ *
+ * The source name is pipeline metadata set by the embedding host before push()
+ * or input-boundary flushes. The op itself is row-local and never opens files.
+ */
+
+#include "internal.h"
+#include "cJSON.h"
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+typedef struct {
+    char *result;
+    char *default_value;
+} source_name_state;
+
+static int source_name_process(tf_step *self, tf_batch *in, tf_batch **out,
+                               tf_side_channels *side) {
+    source_name_state *st = self ? self->state : NULL;
+    if (!st || !in || !out) return TF_ERROR;
+    *out = NULL;
+
+    if (tf_batch_col_index(in, st->result) >= 0) {
+        char msg[256];
+        snprintf(msg, sizeof(msg), "source-name result column already exists: %s", st->result);
+        tf_set_last_error(msg);
+        return TF_ERROR;
+    }
+
+    const char *extra_names[1] = {st->result};
+    tf_type extra_types[1] = {TF_TYPE_STRING};
+    tf_batch *ob = tf_batch_create(in->n_cols + 1, in->n_rows > 0 ? in->n_rows : 1);
+    if (!ob) return TF_ERROR;
+    if (tf_batch_clone_with_extra_cols(ob, in, extra_names, extra_types, 1) != TF_OK) {
+        tf_batch_free(ob);
+        return TF_ERROR;
+    }
+
+    const char *value = st->default_value ? st->default_value : "";
+    if (side && side->source_name && side->source_name[0]) value = side->source_name;
+
+    for (size_t r = 0; r < in->n_rows; r++) {
+        if (tf_batch_copy_row(ob, r, in, r) != TF_OK) {
+            tf_batch_free(ob);
+            return TF_ERROR;
+        }
+        if (tf_batch_set_string(ob, r, in->n_cols, value) != TF_OK) {
+            tf_batch_free(ob);
+            return TF_ERROR;
+        }
+        if (tf_batch_expose_row(ob, r) != TF_OK) {
+            tf_batch_free(ob);
+            return TF_ERROR;
+        }
+    }
+
+    if (ob->n_rows > 0) {
+        *out = ob;
+    } else {
+        tf_batch_free(ob);
+    }
+    return TF_OK;
+}
+
+static int source_name_flush(tf_step *self, tf_batch **out, tf_side_channels *side) {
+    (void)self;
+    (void)side;
+    *out = NULL;
+    return TF_OK;
+}
+
+static void source_name_destroy(tf_step *self) {
+    if (!self) return;
+    source_name_state *st = self->state;
+    if (st) {
+        free(st->result);
+        free(st->default_value);
+        free(st);
+    }
+    free(self);
+}
+
+tf_step *tf_source_name_create(const cJSON *args) {
+    const char *result = "_source";
+    const char *default_value = "";
+    if (args) {
+        cJSON *res = cJSON_GetObjectItemCaseSensitive(args, "result");
+        if (!cJSON_IsString(res)) res = cJSON_GetObjectItemCaseSensitive(args, "column");
+        if (!cJSON_IsString(res)) res = cJSON_GetObjectItemCaseSensitive(args, "as");
+        if (cJSON_IsString(res) && res->valuestring && res->valuestring[0]) result = res->valuestring;
+        cJSON *def = cJSON_GetObjectItemCaseSensitive(args, "default");
+        if (cJSON_IsString(def) && def->valuestring) default_value = def->valuestring;
+    }
+
+    source_name_state *st = calloc(1, sizeof(source_name_state));
+    if (!st) return NULL;
+    st->result = strdup(result);
+    st->default_value = strdup(default_value);
+    if (!st->result || !st->default_value) {
+        free(st->result);
+        free(st->default_value);
+        free(st);
+        return NULL;
+    }
+
+    tf_step *step = calloc(1, sizeof(tf_step));
+    if (!step) {
+        free(st->result);
+        free(st->default_value);
+        free(st);
+        return NULL;
+    }
+    step->process = source_name_process;
+    step->flush = source_name_flush;
+    step->destroy = source_name_destroy;
+    step->state = st;
+    return step;
+}

package/csrc/op_split.c

@@ -22,44 +22,69 @@ static int split_process(tf_step *self, tf_batch *in, tf_batch **out,
     split_state *st = self->state;
     *out = NULL;
 
-    size_t out_cols = in->n_cols + st->n_names;
+    size_t out_cols = 0;
+    if (tf_size_add(in->n_cols, st->n_names, &out_cols) != TF_OK) return TF_ERROR;
     tf_batch *ob = tf_batch_create(out_cols, in->n_rows);
     if (!ob) return TF_ERROR;
 
     /* Copy existing schema */
-    for (size_t c = 0; c < in->n_cols; c++)
-        tf_batch_set_schema(ob, c, in->col_names[c], in->col_types[c]);
+    for (size_t c = 0; c < in->n_cols; c++) {
+        if (tf_batch_set_schema(ob, c, in->col_names[c], in->col_types[c]) != TF_OK) {
+            tf_batch_free(ob);
+            return TF_ERROR;
+        }
+    }
     /* Add new columns */
-    for (size_t k = 0; k < st->n_names; k++)
-        tf_batch_set_schema(ob, in->n_cols + k, st->names[k], TF_TYPE_STRING);
+    for (size_t k = 0; k < st->n_names; k++) {
+        if (tf_batch_set_schema(ob, in->n_cols + k, st->names[k], TF_TYPE_STRING) != TF_OK) {
+            tf_batch_free(ob);
+            return TF_ERROR;
+        }
+    }
 
     int ci = tf_batch_col_index(in, st->column);
     size_t delim_len = strlen(st->delimiter);
 
     for (size_t r = 0; r < in->n_rows; r++) {
-        tf_batch_copy_row(ob, r, in, r);
+        if (tf_batch_copy_row(ob, r, in, r) != TF_OK) {
+            tf_batch_free(ob);
+            return TF_ERROR;
+        }
         /* Initialize new columns as null */
-        for (size_t k = 0; k < st->n_names; k++)
-            tf_batch_set_null(ob, r, in->n_cols + k);
+        for (size_t k = 0; k < st->n_names; k++) {
+            if (tf_batch_set_null(ob, r, in->n_cols + k) != TF_OK) {
+                tf_batch_free(ob);
+                return TF_ERROR;
+            }
+        }
 
         if (ci >= 0 && !tf_batch_is_null(in, r, ci) && in->col_types[ci] == TF_TYPE_STRING) {
             const char *val = tf_batch_get_string(in, r, ci);
-            const char *p = val;
+            const char *p = val ? val : "";
             for (size_t k = 0; k < st->n_names && *p; k++) {
                 const char *found = strstr(p, st->delimiter);
                 size_t tok_len = found ? (size_t)(found - p) : strlen(p);
                 char *tok = malloc(tok_len + 1);
-                if (tok) {
-                    memcpy(tok, p, tok_len);
-                    tok[tok_len] = '\0';
-                    tf_batch_set_string(ob, r, in->n_cols + k, tok);
-                    free(tok);
+                if (!tok) {
+                    tf_batch_free(ob);
+                    return TF_ERROR;
+                }
+                memcpy(tok, p, tok_len);
+                tok[tok_len] = '\0';
+                int rc = tf_batch_set_string(ob, r, in->n_cols + k, tok);
+                free(tok);
+                if (rc != TF_OK) {
+                    tf_batch_free(ob);
+                    return TF_ERROR;
                 }
                 if (found) p = found + delim_len;
                 else break;
             }
         }
-        ob->n_rows = r + 1;
+        if (tf_batch_expose_row(ob, r) != TF_OK) {
+            tf_batch_free(ob);
+            return TF_ERROR;
+        }
     }
 
     *out = ob;
@@ -70,14 +95,19 @@ static int split_flush(tf_step *self, tf_batch **out, tf_side_channels *side) {
     (void)self; (void)side; *out = NULL; return TF_OK;
 }
 
-static void split_destroy(tf_step *self) {
-    split_state *st = self->state;
-    if (st) {
-        free(st->column); free(st->delimiter);
+static void split_state_free(split_state *st) {
+    if (!st) return;
+    free(st->column);
+    free(st->delimiter);
+    if (st->names) {
         for (size_t i = 0; i < st->n_names; i++) free(st->names[i]);
-        free(st->names);
-        free(st);
     }
+    free(st->names);
+    free(st);
+}
+
+static void split_destroy(tf_step *self) {
+    split_state_free(self ? self->state : NULL);
     free(self);
 }
 
@@ -93,19 +123,26 @@ tf_step *tf_split_create(const cJSON *args) {
     split_state *st = calloc(1, sizeof(split_state));
     if (!st) return NULL;
     st->column = strdup(col_j->valuestring);
+    if (!st->column) { split_state_free(st); return NULL; }
 
     cJSON *delim_j = cJSON_GetObjectItemCaseSensitive(args, "delimiter");
-    st->delimiter = strdup(cJSON_IsString(delim_j) ? delim_j->valuestring : " ");
-
-    st->names = calloc(n, sizeof(char *));
-    st->n_names = n;
+    const char *delim = cJSON_IsString(delim_j) ? delim_j->valuestring : " ";
+    if (delim[0] == '\0') { split_state_free(st); return NULL; }
+    st->delimiter = strdup(delim);
+    if (!st->delimiter) { split_state_free(st); return NULL; }
+
+    st->names = calloc((size_t)n, sizeof(char *));
+    if (!st->names) { split_state_free(st); return NULL; }
+    st->n_names = (size_t)n;
     for (int i = 0; i < n; i++) {
         cJSON *item = cJSON_GetArrayItem(names_j, i);
-        if (cJSON_IsString(item)) st->names[i] = strdup(item->valuestring);
+        if (!cJSON_IsString(item)) { split_state_free(st); return NULL; }
+        st->names[i] = strdup(item->valuestring);
+        if (!st->names[i]) { split_state_free(st); return NULL; }
     }
 
-    tf_step *step = malloc(sizeof(tf_step));
-    if (!step) { split_destroy(&(tf_step){.state = st}); return NULL; }
+    tf_step *step = calloc(1, sizeof(tf_step));
+    if (!step) { split_state_free(st); return NULL; }
     step->process = split_process;
     step->flush = split_flush;
     step->destroy = split_destroy;

package/csrc/op_split_data.c

@@ -7,6 +7,7 @@
 
 #include "internal.h"
 #include "cJSON.h"
+#include <math.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
@@ -32,19 +33,31 @@ static int split_data_process(tf_step *self, tf_batch *in, tf_batch **out,
     split_data_state *st = self->state;
     *out = NULL;
 
+    const char *extra_names[1] = {st->result};
+    tf_type extra_types[1] = {TF_TYPE_STRING};
     tf_batch *ob = tf_batch_create(in->n_cols + 1, in->n_rows);
     if (!ob) return TF_ERROR;
-    for (size_t c = 0; c < in->n_cols; c++)
-        tf_batch_set_schema(ob, c, in->col_names[c], in->col_types[c]);
-    tf_batch_set_schema(ob, in->n_cols, st->result, TF_TYPE_STRING);
+    if (tf_batch_clone_with_extra_cols(ob, in, extra_names, extra_types, 1) != TF_OK) {
+        tf_batch_free(ob);
+        return TF_ERROR;
+    }
 
     for (size_t r = 0; r < in->n_rows; r++) {
-        tf_batch_copy_row(ob, r, in, r);
+        if (tf_batch_copy_row(ob, r, in, r) != TF_OK) {
+            tf_batch_free(ob);
+            return TF_ERROR;
+        }
 
         double rval = lcg_random(st->seed, st->row_index);
         const char *label = (rval < st->ratio) ? "train" : "test";
-        tf_batch_set_string(ob, r, in->n_cols, label);
-        ob->n_rows = r + 1;
+        if (tf_batch_set_string(ob, r, in->n_cols, label) != TF_OK) {
+            tf_batch_free(ob);
+            return TF_ERROR;
+        }
+        if (tf_batch_expose_row(ob, r) != TF_OK) {
+            tf_batch_free(ob);
+            return TF_ERROR;
+        }
         st->row_index++;
     }
 
@@ -69,15 +82,34 @@ tf_step *tf_split_data_create(const cJSON *args) {
     if (!st) return NULL;
 
     cJSON *ratio_j = cJSON_GetObjectItemCaseSensitive(args, "ratio");
-    st->ratio = cJSON_IsNumber(ratio_j) ? ratio_j->valuedouble : 0.8;
+    st->ratio = 0.8;
+    if (ratio_j) {
+        if (!cJSON_IsNumber(ratio_j) || !isfinite(ratio_j->valuedouble) ||
+            ratio_j->valuedouble < 0.0 || ratio_j->valuedouble > 1.0) {
+            tf_set_last_error("split-data: ratio must be a finite number between 0 and 1");
+            free(st);
+            return NULL;
+        }
+        st->ratio = ratio_j->valuedouble;
+    }
 
     cJSON *seed_j = cJSON_GetObjectItemCaseSensitive(args, "seed");
-    st->seed = cJSON_IsNumber(seed_j) ? (uint64_t)seed_j->valueint : 42;
+    st->seed = 42;
+    if (seed_j) {
+        size_t parsed_seed = 0;
+        if (tf_json_size_value(seed_j, "seed", 0, TF_MAX_SAFE_SIZE_ARG,
+                               &parsed_seed, "split-data") < 0) {
+            free(st);
+            return NULL;
+        }
+        st->seed = (uint64_t)parsed_seed;
+    }
 
     cJSON *res_j = cJSON_GetObjectItemCaseSensitive(args, "result");
     st->result = strdup(cJSON_IsString(res_j) ? res_j->valuestring : "_split");
+    if (!st->result) { free(st); return NULL; }
 
-    tf_step *step = malloc(sizeof(tf_step));
+    tf_step *step = calloc(1, sizeof(tf_step));
     if (!step) { free(st->result); free(st); return NULL; }
     step->process = split_data_process;
     step->flush = split_data_flush;