chaine 4.0.0b2__cp314-cp314-musllinux_1_2_x86_64.whl

chaine/_core/crfsuite/lib/crf/src/logging.c

@@ -0,0 +1,85 @@
+/*
+ *      Logging utility.
+ *
+ * Copyright (c) 2007-2010, Naoaki Okazaki
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the names of the authors nor the names of its contributors
+ *       may be used to endorse or promote products derived from this
+ *       software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* $Id$ */
+
+#include <os.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#include <crfsuite.h>
+#include "logging.h"
+
+void logging(logging_t *lg, const char *format, ...)
+{
+    va_list args;
+    va_start(args, format);
+
+    if (lg != NULL && lg->func != NULL)
+    {
+        lg->func(lg->instance, format, args);
+    }
+}
+
+void logging_timestamp(logging_t *lg, const char *format)
+{
+    time_t ts;
+    char timestamp[80];
+
+    time(&ts);
+    strftime(
+        timestamp, sizeof(timestamp),
+        "%Y-%m-%dT%H:%M:%SZ",
+        gmtime(&ts));
+    logging(lg, format, timestamp);
+}
+
+void logging_progress(logging_t *lg, int percent)
+{
+    while (lg->percent < percent)
+    {
+        ++lg->percent;
+        if (lg->percent % 2 == 0)
+        {
+            if (lg->percent % 10 == 0)
+            {
+                logging(lg, "Processed %d%% of the training data", lg->percent);
+            }
+        }
+    }
+}
+
+void logging_progress_end(logging_t *lg)
+{
+    logging_progress(lg, 100);
+}

chaine/_core/crfsuite/lib/crf/src/params.c

@@ -0,0 +1,370 @@
+/*
+ *      Parameter exchange.
+ *
+ * Copyright (c) 2007-2010, Naoaki Okazaki
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the names of the authors nor the names of its contributors
+ *       may be used to endorse or promote products derived from this
+ *       software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* $Id$ */
+
+#include <os.h>
+
+#include <stdlib.h>
+#include <string.h>
+
+#include <crfsuite.h>
+#include "quark.h"
+
+enum
+{
+    PT_NONE = 0,
+    PT_INT,
+    PT_FLOAT,
+    PT_STRING,
+};
+
+typedef struct
+{
+    char *name;
+    int type;
+    int val_i;
+    floatval_t val_f;
+    char *val_s;
+    char *help;
+} param_t;
+
+typedef struct
+{
+    int num_params;
+    param_t *params;
+} params_t;
+
+static char *mystrdup(const char *src)
+{
+    char *dst = (char *)malloc(strlen(src) + 1);
+    if (dst != NULL)
+    {
+        strcpy(dst, src);
+    }
+    return dst;
+}
+
+static int params_addref(crfsuite_params_t *params)
+{
+    return crfsuite_interlocked_increment(&params->nref);
+}
+
+static int params_release(crfsuite_params_t *params)
+{
+    int count = crfsuite_interlocked_decrement(&params->nref);
+    if (count == 0)
+    {
+        int i;
+        params_t *pars = (params_t *)params->internal;
+        for (i = 0; i < pars->num_params; ++i)
+        {
+            free(pars->params[i].name);
+            free(pars->params[i].val_s);
+            free(pars->params[i].help);
+        }
+        free(pars->params);
+        free(pars);
+        free(params);
+    }
+    return count;
+}
+
+static param_t *find_param(params_t *pars, const char *name)
+{
+    int i;
+
+    for (i = 0; i < pars->num_params; ++i)
+    {
+        if (strcmp(pars->params[i].name, name) == 0)
+        {
+            return &pars->params[i];
+        }
+    }
+
+    return NULL;
+}
+
+static int params_num(crfsuite_params_t *params)
+{
+    params_t *pars = (params_t *)params->internal;
+    return pars->num_params;
+}
+
+static int params_name(crfsuite_params_t *params, int i, char **ptr_name)
+{
+    params_t *pars = (params_t *)params->internal;
+    *ptr_name = mystrdup(pars->params[i].name);
+    return 0;
+}
+
+static int params_set(crfsuite_params_t *params, const char *name, const char *value)
+{
+    params_t *pars = (params_t *)params->internal;
+    param_t *par = find_param(pars, name);
+    if (par == NULL)
+        return -1;
+    switch (par->type)
+    {
+    case PT_INT:
+        par->val_i = (value != NULL) ? atoi(value) : 0;
+        break;
+    case PT_FLOAT:
+        par->val_f = (value != NULL) ? (floatval_t)atof(value) : 0;
+        break;
+    case PT_STRING:
+        free(par->val_s);
+        par->val_s = (value != NULL) ? mystrdup(value) : mystrdup("");
+    }
+    return 0;
+}
+
+static int params_get(crfsuite_params_t *params, const char *name, char **value)
+{
+    char buffer[1024];
+    params_t *pars = (params_t *)params->internal;
+    param_t *par = find_param(pars, name);
+    if (par == NULL)
+        return -1;
+    switch (par->type)
+    {
+    case PT_INT:
+        snprintf(buffer, sizeof(buffer) - 1, "%d", par->val_i);
+        *value = mystrdup(buffer);
+        break;
+    case PT_FLOAT:
+        snprintf(buffer, sizeof(buffer) - 1, "%f", par->val_f);
+        *value = mystrdup(buffer);
+        break;
+    case PT_STRING:
+        *value = mystrdup(par->val_s);
+    }
+    return 0;
+}
+
+static void params_free(crfsuite_params_t *params, const char *value)
+{
+    free((char *)value);
+}
+
+static int params_set_int(crfsuite_params_t *params, const char *name, int value)
+{
+    params_t *pars = (params_t *)params->internal;
+    param_t *par = find_param(pars, name);
+    if (par == NULL)
+        return -1;
+    if (par->type != PT_INT)
+        return -1;
+    par->val_i = value;
+    return 0;
+}
+
+static int params_set_float(crfsuite_params_t *params, const char *name, floatval_t value)
+{
+    params_t *pars = (params_t *)params->internal;
+    param_t *par = find_param(pars, name);
+    if (par == NULL)
+        return -1;
+    if (par->type != PT_FLOAT)
+        return -1;
+    par->val_f = value;
+    return 0;
+}
+
+static int params_set_string(crfsuite_params_t *params, const char *name, const char *value)
+{
+    params_t *pars = (params_t *)params->internal;
+    param_t *par = find_param(pars, name);
+    if (par == NULL)
+        return -1;
+    if (par->type != PT_STRING)
+        return -1;
+    free(par->val_s);
+    par->val_s = mystrdup(value);
+    return 0;
+}
+
+static int params_get_int(crfsuite_params_t *params, const char *name, int *value)
+{
+    params_t *pars = (params_t *)params->internal;
+    param_t *par = find_param(pars, name);
+    if (par == NULL)
+        return -1;
+    if (par->type != PT_INT)
+        return -1;
+    *value = par->val_i;
+    return 0;
+}
+
+static int params_get_float(crfsuite_params_t *params, const char *name, floatval_t *value)
+{
+    params_t *pars = (params_t *)params->internal;
+    param_t *par = find_param(pars, name);
+    if (par == NULL)
+        return -1;
+    if (par->type != PT_FLOAT)
+        return -1;
+    *value = par->val_f;
+    return 0;
+}
+
+static int params_get_string(crfsuite_params_t *params, const char *name, char **value)
+{
+    params_t *pars = (params_t *)params->internal;
+    param_t *par = find_param(pars, name);
+    if (par == NULL)
+        return -1;
+    if (par->type != PT_STRING)
+        return -1;
+    *value = par->val_s;
+    return 0;
+}
+
+static int params_help(crfsuite_params_t *params, const char *name, char **ptr_type, char **ptr_help)
+{
+    params_t *pars = (params_t *)params->internal;
+    param_t *par = find_param(pars, name);
+    if (par == NULL)
+        return -1;
+    if (ptr_type != NULL)
+    {
+        switch (par->type)
+        {
+        case PT_INT:
+            *ptr_type = mystrdup("int");
+            break;
+        case PT_FLOAT:
+            *ptr_type = mystrdup("float");
+            break;
+        case PT_STRING:
+            *ptr_type = mystrdup("string");
+            break;
+        default:
+            *ptr_type = mystrdup("unknown");
+        }
+    }
+    if (ptr_help != NULL)
+    {
+        *ptr_help = mystrdup(par->help);
+    }
+    return 0;
+}
+
+crfsuite_params_t *params_create_instance()
+{
+    crfsuite_params_t *params = (crfsuite_params_t *)calloc(1, sizeof(crfsuite_params_t));
+
+    if (params != NULL)
+    {
+        /* Construct the internal data. */
+        params->internal = (params_t *)calloc(1, sizeof(params_t));
+        if (params->internal == NULL)
+        {
+            free(params);
+            return NULL;
+        }
+
+        /* Set member functions. */
+        params->nref = 1;
+        params->addref = params_addref;
+        params->release = params_release;
+        params->num = params_num;
+        params->name = params_name;
+        params->set = params_set;
+        params->get = params_get;
+        params->free = params_free;
+        params->set_int = params_set_int;
+        params->set_float = params_set_float;
+        params->set_string = params_set_string;
+        params->get_int = params_get_int;
+        params->get_float = params_get_float;
+        params->get_string = params_get_string;
+        params->help = params_help;
+    }
+
+    return params;
+}
+
+int params_add_int(crfsuite_params_t *params, const char *name, int value, const char *help)
+{
+    param_t *par = NULL;
+    params_t *pars = (params_t *)params->internal;
+    pars->params = (param_t *)realloc(pars->params, (pars->num_params + 1) * sizeof(param_t));
+    if (pars->params == NULL)
+    {
+        return -1;
+    }
+
+    par = &pars->params[pars->num_params++];
+    memset(par, 0, sizeof(*par));
+    par->name = mystrdup(name);
+    par->type = PT_INT;
+    par->val_i = value;
+    par->help = mystrdup(help);
+    return 0;
+}
+
+int params_add_float(crfsuite_params_t *params, const char *name, floatval_t value, const char *help)
+{
+    param_t *par = NULL;
+    params_t *pars = (params_t *)params->internal;
+    pars->params = (param_t *)realloc(pars->params, (pars->num_params + 1) * sizeof(param_t));
+    if (pars->params == NULL)
+    {
+        return -1;
+    }
+
+    par = &pars->params[pars->num_params++];
+    memset(par, 0, sizeof(*par));
+    par->name = mystrdup(name);
+    par->type = PT_FLOAT;
+    par->val_f = value;
+    par->help = mystrdup(help);
+    return 0;
+}
+
+int params_add_string(crfsuite_params_t *params, const char *name, const char *value, const char *help)
+{
+    param_t *par = NULL;
+    params_t *pars = (params_t *)params->internal;
+    pars->params = (param_t *)realloc(pars->params, (pars->num_params + 1) * sizeof(param_t));
+    if (pars->params == NULL)
+    {
+        return -1;
+    }
+
+    par = &pars->params[pars->num_params++];
+    memset(par, 0, sizeof(*par));
+    par->name = mystrdup(name);
+    par->type = PT_STRING;
+    par->val_s = mystrdup(value);
+    par->help = mystrdup(help);
+    return 0;
+}

chaine/_core/crfsuite/lib/crf/src/quark.c

@@ -0,0 +1,180 @@
+/*
+ *      Quark object.
+ *
+ * Copyright (c) 2007-2010, Naoaki Okazaki
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the names of the authors nor the names of its contributors
+ *       may be used to endorse or promote products derived from this
+ *       software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* $Id$ */
+
+#include "os.h"
+#include <stdlib.h>
+#include <string.h>
+#include "rumavl.h"
+#include "quark.h"
+
+typedef struct
+{
+    char *str;
+    int qid;
+} record_t;
+
+struct tag_quark
+{
+    int num;
+    int max;
+    RUMAVL *string_to_id;
+    char **id_to_string;
+};
+
+static int keycmp(const void *_x, const void *_y, size_t n, void *udata)
+{
+    const record_t *x = (const record_t *)_x;
+    const record_t *y = (const record_t *)_y;
+    return strcmp(x->str, y->str);
+}
+
+static int owcb(RUMAVL *tree, RUMAVL_NODE *n, void *_x, const void *_y, void *udata)
+{
+    record_t *x = (record_t *)_x;
+    free(x->str);
+    return 0;
+}
+
+static int delcb(RUMAVL *tree, RUMAVL_NODE *n, void *_record, void *udata)
+{
+    record_t *record = (record_t *)_record;
+    free(record->str);
+    return 0;
+}
+
+quark_t *quark_new()
+{
+    quark_t *qrk = (quark_t *)malloc(sizeof(quark_t));
+    if (qrk != NULL)
+    {
+        qrk->num = 0;
+        qrk->max = 0;
+        qrk->string_to_id = rumavl_new(sizeof(record_t), keycmp, NULL, NULL);
+        if (qrk->string_to_id != NULL)
+        {
+            *rumavl_delcb(qrk->string_to_id) = delcb;
+            *rumavl_owcb(qrk->string_to_id) = owcb;
+        }
+        qrk->id_to_string = NULL;
+    }
+    return qrk;
+}
+
+void quark_delete(quark_t *qrk)
+{
+    if (qrk != NULL)
+    {
+        rumavl_destroy(qrk->string_to_id);
+        free(qrk->id_to_string);
+        free(qrk);
+    }
+}
+
+int quark_get(quark_t *qrk, const char *str)
+{
+    record_t key, *record = NULL;
+
+    key.str = (char *)str;
+    record = (record_t *)rumavl_find(qrk->string_to_id, &key);
+    if (record == NULL)
+    {
+        char *newstr = (char *)malloc(strlen(str) + 1);
+        if (newstr != NULL)
+        {
+            strcpy(newstr, str);
+        }
+
+        if (qrk->max <= qrk->num)
+        {
+            qrk->max = (qrk->max + 1) * 2;
+            qrk->id_to_string = (char **)realloc(qrk->id_to_string, sizeof(char *) * qrk->max);
+        }
+
+        qrk->id_to_string[qrk->num] = newstr;
+        key.str = newstr;
+        key.qid = qrk->num;
+        rumavl_insert(qrk->string_to_id, &key);
+
+        ++qrk->num;
+        return key.qid;
+    }
+    else
+    {
+        return record->qid;
+    }
+}
+
+int quark_to_id(quark_t *qrk, const char *str)
+{
+    record_t key, *record = NULL;
+
+    key.str = (char *)str;
+    record = (record_t *)rumavl_find(qrk->string_to_id, &key);
+    return (record != NULL) ? record->qid : -1;
+}
+
+const char *quark_to_string(quark_t *qrk, int qid)
+{
+    return (qid < qrk->num) ? qrk->id_to_string[qid] : NULL;
+}
+
+int quark_num(quark_t *qrk)
+{
+    return qrk->num;
+}
+
+#if 0
+int main(int argc, char *argv[])
+{
+    quark_t *qrk = quark_new();
+    int qid = 0;
+
+    qid = quark_get(qrk, "zero");
+    qid = quark_get(qrk, "one");
+    qid = quark_get(qrk, "zero");
+    qid = quark_to_id(qrk, "three");
+    qid = quark_get(qrk, "two");
+    qid = quark_get(qrk, "three");
+    qid = quark_to_id(qrk, "three");
+    qid = quark_get(qrk, "zero");
+    qid = quark_get(qrk, "one");
+
+    printf("%s\n", quark_to_string(qrk, 0));
+    printf("%s\n", quark_to_string(qrk, 1));
+    printf("%s\n", quark_to_string(qrk, 2));
+    printf("%s\n", quark_to_string(qrk, 3));
+
+    quark_delete(qrk);
+    
+    return 0;
+}
+#endif