Merge branch 'collectd-5.7'
[collectd.git] / src / pyvalues.c
1 /**
2  * collectd - src/pyvalues.c
3  * Copyright (C) 2009  Sven Trenkel
4  *
5  * Permission is hereby granted, free of charge, to any person obtaining a
6  * copy of this software and associated documentation files (the "Software"),
7  * to deal in the Software without restriction, including without limitation
8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9  * and/or sell copies of the Software, and to permit persons to whom the
10  * Software is furnished to do so, subject to the following conditions:
11  *
12  * The above copyright notice and this permission notice shall be included in
13  * all copies or substantial portions of the Software.
14  *
15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21  * DEALINGS IN THE SOFTWARE.
22  *
23  * Authors:
24  *   Sven Trenkel <collectd at semidefinite.de>
25  **/
26
27 #include <Python.h>
28 #include <structmember.h>
29
30 #include "collectd.h"
31
32 #include "common.h"
33
34 #include "cpython.h"
35
36 #define FreeAll()                                                              \
37   do {                                                                         \
38     PyMem_Free(type);                                                          \
39     PyMem_Free(plugin_instance);                                               \
40     PyMem_Free(type_instance);                                                 \
41     PyMem_Free(plugin);                                                        \
42     PyMem_Free(host);                                                          \
43   } while (0)
44
45 static PyObject *cpy_common_repr(PyObject *s) {
46   PyObject *ret, *tmp;
47   static PyObject *l_type = NULL, *l_type_instance = NULL, *l_plugin = NULL,
48                   *l_plugin_instance = NULL;
49   static PyObject *l_host = NULL, *l_time = NULL;
50   PluginData *self = (PluginData *)s;
51
52   if (l_type == NULL)
53     l_type = cpy_string_to_unicode_or_bytes("(type=");
54   if (l_type_instance == NULL)
55     l_type_instance = cpy_string_to_unicode_or_bytes(",type_instance=");
56   if (l_plugin == NULL)
57     l_plugin = cpy_string_to_unicode_or_bytes(",plugin=");
58   if (l_plugin_instance == NULL)
59     l_plugin_instance = cpy_string_to_unicode_or_bytes(",plugin_instance=");
60   if (l_host == NULL)
61     l_host = cpy_string_to_unicode_or_bytes(",host=");
62   if (l_time == NULL)
63     l_time = cpy_string_to_unicode_or_bytes(",time=");
64
65   if (!l_type || !l_type_instance || !l_plugin || !l_plugin_instance ||
66       !l_host || !l_time)
67     return NULL;
68
69   ret = cpy_string_to_unicode_or_bytes(s->ob_type->tp_name);
70
71   CPY_STRCAT(&ret, l_type);
72   tmp = cpy_string_to_unicode_or_bytes(self->type);
73   CPY_SUBSTITUTE(PyObject_Repr, tmp, tmp);
74   CPY_STRCAT_AND_DEL(&ret, tmp);
75
76   if (self->type_instance[0] != 0) {
77     CPY_STRCAT(&ret, l_type_instance);
78     tmp = cpy_string_to_unicode_or_bytes(self->type_instance);
79     CPY_SUBSTITUTE(PyObject_Repr, tmp, tmp);
80     CPY_STRCAT_AND_DEL(&ret, tmp);
81   }
82
83   if (self->plugin[0] != 0) {
84     CPY_STRCAT(&ret, l_plugin);
85     tmp = cpy_string_to_unicode_or_bytes(self->plugin);
86     CPY_SUBSTITUTE(PyObject_Repr, tmp, tmp);
87     CPY_STRCAT_AND_DEL(&ret, tmp);
88   }
89
90   if (self->plugin_instance[0] != 0) {
91     CPY_STRCAT(&ret, l_plugin_instance);
92     tmp = cpy_string_to_unicode_or_bytes(self->plugin_instance);
93     CPY_SUBSTITUTE(PyObject_Repr, tmp, tmp);
94     CPY_STRCAT_AND_DEL(&ret, tmp);
95   }
96
97   if (self->host[0] != 0) {
98     CPY_STRCAT(&ret, l_host);
99     tmp = cpy_string_to_unicode_or_bytes(self->host);
100     CPY_SUBSTITUTE(PyObject_Repr, tmp, tmp);
101     CPY_STRCAT_AND_DEL(&ret, tmp);
102   }
103
104   if (self->time != 0) {
105     CPY_STRCAT(&ret, l_time);
106     tmp = PyFloat_FromDouble(self->time);
107     CPY_SUBSTITUTE(PyObject_Repr, tmp, tmp);
108     CPY_STRCAT_AND_DEL(&ret, tmp);
109   }
110   return ret;
111 }
112
113 static char time_doc[] =
114     "This is the Unix timestamp of the time this value was read.\n"
115     "For dispatching values this can be set to 0 which means \"now\".\n"
116     "This means the time the value is actually dispatched, not the time\n"
117     "it was set to 0.";
118
119 static char host_doc[] =
120     "The hostname of the host this value was read from.\n"
121     "For dispatching this can be set to an empty string which means\n"
122     "the local hostname as defined in collectd.conf.";
123
124 static char type_doc[] =
125     "The type of this value. This type has to be defined\n"
126     "in the types.db file. Attempting to set it to any other value\n"
127     "will raise a TypeError exception.\n"
128     "Assigning a type is mandatory, calling dispatch without doing\n"
129     "so will raise a RuntimeError exception.";
130
131 static char type_instance_doc[] = "";
132
133 static char plugin_doc[] =
134     "The name of the plugin that read the data. Setting this\n"
135     "member to an empty string will insert \"python\" upon dispatching.";
136
137 static char plugin_instance_doc[] = "";
138
139 static char PluginData_doc[] =
140     "This is an internal class that is the base for Values\n"
141     "and Notification. It is pretty useless by itself and is therefore not\n"
142     "exported to the collectd module.";
143
144 static PyObject *PluginData_new(PyTypeObject *type, PyObject *args,
145                                 PyObject *kwds) {
146   PluginData *self;
147
148   self = (PluginData *)type->tp_alloc(type, 0);
149   if (self == NULL)
150     return NULL;
151
152   self->time = 0;
153   self->host[0] = 0;
154   self->plugin[0] = 0;
155   self->plugin_instance[0] = 0;
156   self->type[0] = 0;
157   self->type_instance[0] = 0;
158   return (PyObject *)self;
159 }
160
161 static int PluginData_init(PyObject *s, PyObject *args, PyObject *kwds) {
162   PluginData *self = (PluginData *)s;
163   double time = 0;
164   char *type = NULL, *plugin_instance = NULL, *type_instance = NULL,
165        *plugin = NULL, *host = NULL;
166   static char *kwlist[] = {
167       "type", "plugin_instance", "type_instance", "plugin", "host", "time",
168       NULL};
169
170   if (!PyArg_ParseTupleAndKeywords(args, kwds, "|etetetetetd", kwlist, NULL,
171                                    &type, NULL, &plugin_instance, NULL,
172                                    &type_instance, NULL, &plugin, NULL, &host,
173                                    &time))
174     return -1;
175
176   if (type && plugin_get_ds(type) == NULL) {
177     PyErr_Format(PyExc_TypeError, "Dataset %s not found", type);
178     FreeAll();
179     return -1;
180   }
181
182   sstrncpy(self->host, host ? host : "", sizeof(self->host));
183   sstrncpy(self->plugin, plugin ? plugin : "", sizeof(self->plugin));
184   sstrncpy(self->plugin_instance, plugin_instance ? plugin_instance : "",
185            sizeof(self->plugin_instance));
186   sstrncpy(self->type, type ? type : "", sizeof(self->type));
187   sstrncpy(self->type_instance, type_instance ? type_instance : "",
188            sizeof(self->type_instance));
189   self->time = time;
190
191   FreeAll();
192
193   return 0;
194 }
195
196 static PyObject *PluginData_repr(PyObject *s) {
197   PyObject *ret;
198   static PyObject *l_closing = NULL;
199
200   if (l_closing == NULL)
201     l_closing = cpy_string_to_unicode_or_bytes(")");
202
203   if (l_closing == NULL)
204     return NULL;
205
206   ret = cpy_common_repr(s);
207   CPY_STRCAT(&ret, l_closing);
208   return ret;
209 }
210
211 static PyMemberDef PluginData_members[] = {
212     {"time", T_DOUBLE, offsetof(PluginData, time), 0, time_doc}, {NULL}};
213
214 static PyObject *PluginData_getstring(PyObject *self, void *data) {
215   const char *value = ((char *)self) + (intptr_t)data;
216
217   return cpy_string_to_unicode_or_bytes(value);
218 }
219
220 static int PluginData_setstring(PyObject *self, PyObject *value, void *data) {
221   char *old;
222   const char *new;
223
224   if (value == NULL) {
225     PyErr_SetString(PyExc_TypeError, "Cannot delete this attribute");
226     return -1;
227   }
228   Py_INCREF(value);
229   new = cpy_unicode_or_bytes_to_string(&value);
230   if (new == NULL) {
231     Py_DECREF(value);
232     return -1;
233   }
234   old = ((char *)self) + (intptr_t)data;
235   sstrncpy(old, new, DATA_MAX_NAME_LEN);
236   Py_DECREF(value);
237   return 0;
238 }
239
240 static int PluginData_settype(PyObject *self, PyObject *value, void *data) {
241   char *old;
242   const char *new;
243
244   if (value == NULL) {
245     PyErr_SetString(PyExc_TypeError, "Cannot delete this attribute");
246     return -1;
247   }
248   Py_INCREF(value);
249   new = cpy_unicode_or_bytes_to_string(&value);
250   if (new == NULL) {
251     Py_DECREF(value);
252     return -1;
253   }
254
255   if (plugin_get_ds(new) == NULL) {
256     PyErr_Format(PyExc_TypeError, "Dataset %s not found", new);
257     Py_DECREF(value);
258     return -1;
259   }
260
261   old = ((char *)self) + (intptr_t)data;
262   sstrncpy(old, new, DATA_MAX_NAME_LEN);
263   Py_DECREF(value);
264   return 0;
265 }
266
267 static PyGetSetDef PluginData_getseters[] = {
268     {"host", PluginData_getstring, PluginData_setstring, host_doc,
269      (void *)offsetof(PluginData, host)},
270     {"plugin", PluginData_getstring, PluginData_setstring, plugin_doc,
271      (void *)offsetof(PluginData, plugin)},
272     {"plugin_instance", PluginData_getstring, PluginData_setstring,
273      plugin_instance_doc, (void *)offsetof(PluginData, plugin_instance)},
274     {"type_instance", PluginData_getstring, PluginData_setstring,
275      type_instance_doc, (void *)offsetof(PluginData, type_instance)},
276     {"type", PluginData_getstring, PluginData_settype, type_doc,
277      (void *)offsetof(PluginData, type)},
278     {NULL}};
279
280 PyTypeObject PluginDataType = {
281     CPY_INIT_TYPE "collectd.PluginData", /* tp_name */
282     sizeof(PluginData),                  /* tp_basicsize */
283     0,                                   /* Will be filled in later */
284     0,                                   /* tp_dealloc */
285     0,                                   /* tp_print */
286     0,                                   /* tp_getattr */
287     0,                                   /* tp_setattr */
288     0,                                   /* tp_compare */
289     PluginData_repr,                     /* tp_repr */
290     0,                                   /* tp_as_number */
291     0,                                   /* tp_as_sequence */
292     0,                                   /* tp_as_mapping */
293     0,                                   /* tp_hash */
294     0,                                   /* tp_call */
295     0,                                   /* tp_str */
296     0,                                   /* tp_getattro */
297     0,                                   /* tp_setattro */
298     0,                                   /* tp_as_buffer */
299     Py_TPFLAGS_DEFAULT |
300         Py_TPFLAGS_BASETYPE /*| Py_TPFLAGS_HAVE_GC*/, /*tp_flags*/
301     PluginData_doc,                                   /* tp_doc */
302     0,                                                /* tp_traverse */
303     0,                                                /* tp_clear */
304     0,                                                /* tp_richcompare */
305     0,                                                /* tp_weaklistoffset */
306     0,                                                /* tp_iter */
307     0,                                                /* tp_iternext */
308     0,                                                /* tp_methods */
309     PluginData_members,                               /* tp_members */
310     PluginData_getseters,                             /* tp_getset */
311     0,                                                /* tp_base */
312     0,                                                /* tp_dict */
313     0,                                                /* tp_descr_get */
314     0,                                                /* tp_descr_set */
315     0,                                                /* tp_dictoffset */
316     PluginData_init,                                  /* tp_init */
317     0,                                                /* tp_alloc */
318     PluginData_new                                    /* tp_new */
319 };
320
321 static char interval_doc[] =
322     "The interval is the timespan in seconds between two submits for\n"
323     "the same data source. This value has to be a positive integer, so you "
324     "can't\n"
325     "submit more than one value per second. If this member is set to a\n"
326     "non-positive value, the default value as specified in the config file "
327     "will\n"
328     "be used (default: 10).\n"
329     "\n"
330     "If you submit values more often than the specified interval, the average\n"
331     "will be used. If you submit less values, your graphs will have gaps.";
332
333 static char values_doc[] =
334     "These are the actual values that get dispatched to collectd.\n"
335     "It has to be a sequence (a tuple or list) of numbers.\n"
336     "The size of the sequence and the type of its content depend on the type\n"
337     "member in the types.db file. For more information on this read the\n"
338     "types.db man page.\n"
339     "\n"
340     "If the sequence does not have the correct size upon dispatch a "
341     "RuntimeError\n"
342     "exception will be raised. If the content of the sequence is not a "
343     "number,\n"
344     "a TypeError exception will be raised.";
345
346 static char meta_doc[] =
347     "These are the meta data for this Value object.\n"
348     "It has to be a dictionary of numbers, strings or bools. All keys must be\n"
349     "strings. int and long objects will be dispatched as signed integers "
350     "unless\n"
351     "they are between 2**63 and 2**64-1, which will result in an unsigned "
352     "integer.\n"
353     "You can force one of these storage classes by using the classes\n"
354     "collectd.Signed and collectd.Unsigned. A meta object received by a write\n"
355     "callback will always contain Signed or Unsigned objects.";
356
357 static char dispatch_doc[] =
358     "dispatch([type][, values][, plugin_instance][, type_instance]"
359     "[, plugin][, host][, time][, interval]) -> None.  Dispatch a value list.\n"
360     "\n"
361     "Dispatch this instance to the collectd process. The object has members\n"
362     "for each of the possible arguments for this method. For a detailed "
363     "explanation\n"
364     "of these parameters see the member of the same same.\n"
365     "\n"
366     "If you do not submit a parameter the value saved in its member will be "
367     "submitted.\n"
368     "If you do provide a parameter it will be used instead, without altering "
369     "the member.";
370
371 static char write_doc[] =
372     "write([destination][, type][, values][, plugin_instance][, type_instance]"
373     "[, plugin][, host][, time][, interval]) -> None.  Dispatch a value list.\n"
374     "\n"
375     "Write this instance to a single plugin or all plugins if 'destination' is "
376     "omitted.\n"
377     "This will bypass the main collectd process and all filtering and "
378     "caching.\n"
379     "Other than that it works similar to 'dispatch'. In most cases 'dispatch' "
380     "should be\n"
381     "used instead of 'write'.\n";
382
383 static char Values_doc[] = "A Values object used for dispatching values to "
384                            "collectd and receiving values from write "
385                            "callbacks.";
386
387 static PyObject *Values_new(PyTypeObject *type, PyObject *args,
388                             PyObject *kwds) {
389   Values *self;
390
391   self = (Values *)PluginData_new(type, args, kwds);
392   if (self == NULL)
393     return NULL;
394
395   self->values = PyList_New(0);
396   self->meta = PyDict_New();
397   self->interval = 0;
398   return (PyObject *)self;
399 }
400
401 static int Values_init(PyObject *s, PyObject *args, PyObject *kwds) {
402   Values *self = (Values *)s;
403   double interval = 0, time = 0;
404   PyObject *values = NULL, *meta = NULL, *tmp;
405   char *type = NULL, *plugin_instance = NULL, *type_instance = NULL,
406        *plugin = NULL, *host = NULL;
407   static char *kwlist[] = {
408       "type", "values", "plugin_instance", "type_instance", "plugin",
409       "host", "time",   "interval",        "meta",          NULL};
410
411   if (!PyArg_ParseTupleAndKeywords(args, kwds, "|etOetetetetddO", kwlist, NULL,
412                                    &type, &values, NULL, &plugin_instance, NULL,
413                                    &type_instance, NULL, &plugin, NULL, &host,
414                                    &time, &interval, &meta))
415     return -1;
416
417   if (type && plugin_get_ds(type) == NULL) {
418     PyErr_Format(PyExc_TypeError, "Dataset %s not found", type);
419     FreeAll();
420     return -1;
421   }
422
423   sstrncpy(self->data.host, host ? host : "", sizeof(self->data.host));
424   sstrncpy(self->data.plugin, plugin ? plugin : "", sizeof(self->data.plugin));
425   sstrncpy(self->data.plugin_instance, plugin_instance ? plugin_instance : "",
426            sizeof(self->data.plugin_instance));
427   sstrncpy(self->data.type, type ? type : "", sizeof(self->data.type));
428   sstrncpy(self->data.type_instance, type_instance ? type_instance : "",
429            sizeof(self->data.type_instance));
430   self->data.time = time;
431
432   FreeAll();
433
434   if (values == NULL) {
435     values = PyList_New(0);
436     PyErr_Clear();
437   } else {
438     Py_INCREF(values);
439   }
440
441   if (meta == NULL) {
442     meta = PyDict_New();
443     PyErr_Clear();
444   } else {
445     Py_INCREF(meta);
446   }
447
448   tmp = self->values;
449   self->values = values;
450   Py_XDECREF(tmp);
451
452   tmp = self->meta;
453   self->meta = meta;
454   Py_XDECREF(tmp);
455
456   self->interval = interval;
457   return 0;
458 }
459
460 static meta_data_t *cpy_build_meta(PyObject *meta) {
461   int s;
462   meta_data_t *m = NULL;
463   PyObject *l;
464
465   if ((meta == NULL) || (meta == Py_None))
466     return NULL;
467
468   l = PyDict_Items(meta); /* New reference. */
469   if (!l) {
470     cpy_log_exception("building meta data");
471     return NULL;
472   }
473   s = PyList_Size(l);
474   if (s <= 0) {
475     Py_XDECREF(l);
476     return NULL;
477   }
478
479   m = meta_data_create();
480   for (int i = 0; i < s; ++i) {
481     const char *string, *keystring;
482     PyObject *key, *value, *item, *tmp;
483
484     item = PyList_GET_ITEM(l, i);
485     key = PyTuple_GET_ITEM(item, 0);
486     Py_INCREF(key);
487     keystring = cpy_unicode_or_bytes_to_string(&key);
488     if (!keystring) {
489       PyErr_Clear();
490       Py_XDECREF(key);
491       continue;
492     }
493     value = PyTuple_GET_ITEM(item, 1);
494     Py_INCREF(value);
495     if (value == Py_True) {
496       meta_data_add_boolean(m, keystring, 1);
497     } else if (value == Py_False) {
498       meta_data_add_boolean(m, keystring, 0);
499     } else if (PyFloat_Check(value)) {
500       meta_data_add_double(m, keystring, PyFloat_AsDouble(value));
501     } else if (PyObject_TypeCheck(value, &SignedType)) {
502       long long int lli;
503       lli = PyLong_AsLongLong(value);
504       if (!PyErr_Occurred() && (lli == (int64_t)lli))
505         meta_data_add_signed_int(m, keystring, lli);
506     } else if (PyObject_TypeCheck(value, &UnsignedType)) {
507       long long unsigned llu;
508       llu = PyLong_AsUnsignedLongLong(value);
509       if (!PyErr_Occurred() && (llu == (uint64_t)llu))
510         meta_data_add_unsigned_int(m, keystring, llu);
511     } else if (PyNumber_Check(value)) {
512       long long int lli;
513       long long unsigned llu;
514       tmp = PyNumber_Long(value);
515       lli = PyLong_AsLongLong(tmp);
516       if (!PyErr_Occurred() && (lli == (int64_t)lli)) {
517         meta_data_add_signed_int(m, keystring, lli);
518       } else {
519         PyErr_Clear();
520         llu = PyLong_AsUnsignedLongLong(tmp);
521         if (!PyErr_Occurred() && (llu == (uint64_t)llu))
522           meta_data_add_unsigned_int(m, keystring, llu);
523       }
524       Py_XDECREF(tmp);
525     } else {
526       string = cpy_unicode_or_bytes_to_string(&value);
527       if (string) {
528         meta_data_add_string(m, keystring, string);
529       } else {
530         PyErr_Clear();
531         tmp = PyObject_Str(value);
532         string = cpy_unicode_or_bytes_to_string(&tmp);
533         if (string)
534           meta_data_add_string(m, keystring, string);
535         Py_XDECREF(tmp);
536       }
537     }
538     if (PyErr_Occurred())
539       cpy_log_exception("building meta data");
540     Py_XDECREF(value);
541     Py_DECREF(key);
542   }
543   Py_XDECREF(l);
544   return m;
545 }
546
547 static PyObject *Values_dispatch(Values *self, PyObject *args, PyObject *kwds) {
548   int ret;
549   const data_set_t *ds;
550   size_t size;
551   value_t *value;
552   value_list_t value_list = VALUE_LIST_INIT;
553   PyObject *values = self->values, *meta = self->meta;
554   double time = self->data.time, interval = self->interval;
555   char *host = NULL, *plugin = NULL, *plugin_instance = NULL, *type = NULL,
556        *type_instance = NULL;
557
558   static char *kwlist[] = {
559       "type", "values", "plugin_instance", "type_instance", "plugin",
560       "host", "time",   "interval",        "meta",          NULL};
561   if (!PyArg_ParseTupleAndKeywords(args, kwds, "|etOetetetetddO", kwlist, NULL,
562                                    &type, &values, NULL, &plugin_instance, NULL,
563                                    &type_instance, NULL, &plugin, NULL, &host,
564                                    &time, &interval, &meta))
565     return NULL;
566
567   sstrncpy(value_list.host, host ? host : self->data.host,
568            sizeof(value_list.host));
569   sstrncpy(value_list.plugin, plugin ? plugin : self->data.plugin,
570            sizeof(value_list.plugin));
571   sstrncpy(value_list.plugin_instance,
572            plugin_instance ? plugin_instance : self->data.plugin_instance,
573            sizeof(value_list.plugin_instance));
574   sstrncpy(value_list.type, type ? type : self->data.type,
575            sizeof(value_list.type));
576   sstrncpy(value_list.type_instance,
577            type_instance ? type_instance : self->data.type_instance,
578            sizeof(value_list.type_instance));
579   FreeAll();
580   if (value_list.type[0] == 0) {
581     PyErr_SetString(PyExc_RuntimeError, "type not set");
582     FreeAll();
583     return NULL;
584   }
585   ds = plugin_get_ds(value_list.type);
586   if (ds == NULL) {
587     PyErr_Format(PyExc_TypeError, "Dataset %s not found", value_list.type);
588     return NULL;
589   }
590   if (values == NULL ||
591       (PyTuple_Check(values) == 0 && PyList_Check(values) == 0)) {
592     PyErr_Format(PyExc_TypeError, "values must be list or tuple");
593     return NULL;
594   }
595   if (meta != NULL && meta != Py_None && !PyDict_Check(meta)) {
596     PyErr_Format(PyExc_TypeError, "meta must be a dict");
597     return NULL;
598   }
599   size = (size_t)PySequence_Length(values);
600   if (size != ds->ds_num) {
601     PyErr_Format(PyExc_RuntimeError, "type %s needs %zu values, got %zu",
602                  value_list.type, ds->ds_num, size);
603     return NULL;
604   }
605   value = calloc(size, sizeof(*value));
606   for (size_t i = 0; i < size; ++i) {
607     PyObject *item, *num;
608     item = PySequence_Fast_GET_ITEM(values, (int)i); /* Borrowed reference. */
609     switch (ds->ds[i].type) {
610     case DS_TYPE_COUNTER:
611       num = PyNumber_Long(item); /* New reference. */
612       if (num != NULL) {
613         value[i].counter = PyLong_AsUnsignedLongLong(num);
614         Py_XDECREF(num);
615       }
616       break;
617     case DS_TYPE_GAUGE:
618       num = PyNumber_Float(item); /* New reference. */
619       if (num != NULL) {
620         value[i].gauge = PyFloat_AsDouble(num);
621         Py_XDECREF(num);
622       }
623       break;
624     case DS_TYPE_DERIVE:
625       /* This might overflow without raising an exception.
626        * Not much we can do about it */
627       num = PyNumber_Long(item); /* New reference. */
628       if (num != NULL) {
629         value[i].derive = PyLong_AsLongLong(num);
630         Py_XDECREF(num);
631       }
632       break;
633     case DS_TYPE_ABSOLUTE:
634       /* This might overflow without raising an exception.
635        * Not much we can do about it */
636       num = PyNumber_Long(item); /* New reference. */
637       if (num != NULL) {
638         value[i].absolute = PyLong_AsUnsignedLongLong(num);
639         Py_XDECREF(num);
640       }
641       break;
642     default:
643       free(value);
644       PyErr_Format(PyExc_RuntimeError, "unknown data type %d for %s",
645                    ds->ds[i].type, value_list.type);
646       return NULL;
647     }
648     if (PyErr_Occurred() != NULL) {
649       free(value);
650       return NULL;
651     }
652   }
653   value_list.values = value;
654   value_list.meta = cpy_build_meta(meta);
655   value_list.values_len = size;
656   value_list.time = DOUBLE_TO_CDTIME_T(time);
657   value_list.interval = DOUBLE_TO_CDTIME_T(interval);
658   if (value_list.host[0] == 0)
659     sstrncpy(value_list.host, hostname_g, sizeof(value_list.host));
660   if (value_list.plugin[0] == 0)
661     sstrncpy(value_list.plugin, "python", sizeof(value_list.plugin));
662   Py_BEGIN_ALLOW_THREADS;
663   ret = plugin_dispatch_values(&value_list);
664   Py_END_ALLOW_THREADS;
665   meta_data_destroy(value_list.meta);
666   free(value);
667   if (ret != 0) {
668     PyErr_SetString(PyExc_RuntimeError,
669                     "error dispatching values, read the logs");
670     return NULL;
671   }
672   Py_RETURN_NONE;
673 }
674
675 static PyObject *Values_write(Values *self, PyObject *args, PyObject *kwds) {
676   int ret;
677   const data_set_t *ds;
678   size_t size;
679   value_t *value;
680   value_list_t value_list = VALUE_LIST_INIT;
681   PyObject *values = self->values, *meta = self->meta;
682   double time = self->data.time, interval = self->interval;
683   char *host = NULL, *plugin = NULL, *plugin_instance = NULL, *type = NULL,
684        *type_instance = NULL, *dest = NULL;
685
686   static char *kwlist[] = {
687       "destination",   "type",   "values", "plugin_instance",
688       "type_instance", "plugin", "host",   "time",
689       "interval",      "meta",   NULL};
690   if (!PyArg_ParseTupleAndKeywords(
691           args, kwds, "et|etOetetetetdiO", kwlist, NULL, &dest, NULL, &type,
692           &values, NULL, &plugin_instance, NULL, &type_instance, NULL, &plugin,
693           NULL, &host, &time, &interval, &meta))
694     return NULL;
695
696   sstrncpy(value_list.host, host ? host : self->data.host,
697            sizeof(value_list.host));
698   sstrncpy(value_list.plugin, plugin ? plugin : self->data.plugin,
699            sizeof(value_list.plugin));
700   sstrncpy(value_list.plugin_instance,
701            plugin_instance ? plugin_instance : self->data.plugin_instance,
702            sizeof(value_list.plugin_instance));
703   sstrncpy(value_list.type, type ? type : self->data.type,
704            sizeof(value_list.type));
705   sstrncpy(value_list.type_instance,
706            type_instance ? type_instance : self->data.type_instance,
707            sizeof(value_list.type_instance));
708   FreeAll();
709   if (value_list.type[0] == 0) {
710     PyErr_SetString(PyExc_RuntimeError, "type not set");
711     return NULL;
712   }
713   ds = plugin_get_ds(value_list.type);
714   if (ds == NULL) {
715     PyErr_Format(PyExc_TypeError, "Dataset %s not found", value_list.type);
716     return NULL;
717   }
718   if (values == NULL ||
719       (PyTuple_Check(values) == 0 && PyList_Check(values) == 0)) {
720     PyErr_Format(PyExc_TypeError, "values must be list or tuple");
721     return NULL;
722   }
723   size = (size_t)PySequence_Length(values);
724   if (size != ds->ds_num) {
725     PyErr_Format(PyExc_RuntimeError, "type %s needs %zu values, got %zu",
726                  value_list.type, ds->ds_num, size);
727     return NULL;
728   }
729   value = calloc(size, sizeof(*value));
730   for (size_t i = 0; i < size; ++i) {
731     PyObject *item, *num;
732     item = PySequence_Fast_GET_ITEM(values, i); /* Borrowed reference. */
733     switch (ds->ds[i].type) {
734     case DS_TYPE_COUNTER:
735       num = PyNumber_Long(item); /* New reference. */
736       if (num != NULL) {
737         value[i].counter = PyLong_AsUnsignedLongLong(num);
738         Py_XDECREF(num);
739       }
740       break;
741     case DS_TYPE_GAUGE:
742       num = PyNumber_Float(item); /* New reference. */
743       if (num != NULL) {
744         value[i].gauge = PyFloat_AsDouble(num);
745         Py_XDECREF(num);
746       }
747       break;
748     case DS_TYPE_DERIVE:
749       /* This might overflow without raising an exception.
750        * Not much we can do about it */
751       num = PyNumber_Long(item); /* New reference. */
752       if (num != NULL) {
753         value[i].derive = PyLong_AsLongLong(num);
754         Py_XDECREF(num);
755       }
756       break;
757     case DS_TYPE_ABSOLUTE:
758       /* This might overflow without raising an exception.
759        * Not much we can do about it */
760       num = PyNumber_Long(item); /* New reference. */
761       if (num != NULL) {
762         value[i].absolute = PyLong_AsUnsignedLongLong(num);
763         Py_XDECREF(num);
764       }
765       break;
766     default:
767       free(value);
768       PyErr_Format(PyExc_RuntimeError, "unknown data type %d for %s",
769                    ds->ds[i].type, value_list.type);
770       return NULL;
771     }
772     if (PyErr_Occurred() != NULL) {
773       free(value);
774       return NULL;
775     }
776   }
777   value_list.values = value;
778   value_list.values_len = size;
779   value_list.time = DOUBLE_TO_CDTIME_T(time);
780   value_list.interval = DOUBLE_TO_CDTIME_T(interval);
781   value_list.meta = cpy_build_meta(meta);
782   if (value_list.host[0] == 0)
783     sstrncpy(value_list.host, hostname_g, sizeof(value_list.host));
784   if (value_list.plugin[0] == 0)
785     sstrncpy(value_list.plugin, "python", sizeof(value_list.plugin));
786   Py_BEGIN_ALLOW_THREADS;
787   ret = plugin_write(dest, NULL, &value_list);
788   Py_END_ALLOW_THREADS;
789   meta_data_destroy(value_list.meta);
790   free(value);
791   if (ret != 0) {
792     PyErr_SetString(PyExc_RuntimeError,
793                     "error dispatching values, read the logs");
794     return NULL;
795   }
796   Py_RETURN_NONE;
797 }
798
799 static PyObject *Values_repr(PyObject *s) {
800   PyObject *ret, *tmp;
801   static PyObject *l_interval = NULL, *l_values = NULL, *l_meta = NULL,
802                   *l_closing = NULL;
803   Values *self = (Values *)s;
804
805   if (l_interval == NULL)
806     l_interval = cpy_string_to_unicode_or_bytes(",interval=");
807   if (l_values == NULL)
808     l_values = cpy_string_to_unicode_or_bytes(",values=");
809   if (l_meta == NULL)
810     l_meta = cpy_string_to_unicode_or_bytes(",meta=");
811   if (l_closing == NULL)
812     l_closing = cpy_string_to_unicode_or_bytes(")");
813
814   if (l_interval == NULL || l_values == NULL || l_meta == NULL ||
815       l_closing == NULL)
816     return NULL;
817
818   ret = cpy_common_repr(s);
819   if (self->interval != 0) {
820     CPY_STRCAT(&ret, l_interval);
821     tmp = PyFloat_FromDouble(self->interval);
822     CPY_SUBSTITUTE(PyObject_Repr, tmp, tmp);
823     CPY_STRCAT_AND_DEL(&ret, tmp);
824   }
825   if (self->values &&
826       (!PyList_Check(self->values) || PySequence_Length(self->values) > 0)) {
827     CPY_STRCAT(&ret, l_values);
828     tmp = PyObject_Repr(self->values);
829     CPY_STRCAT_AND_DEL(&ret, tmp);
830   }
831   if (self->meta &&
832       (!PyDict_Check(self->meta) || PyDict_Size(self->meta) > 0)) {
833     CPY_STRCAT(&ret, l_meta);
834     tmp = PyObject_Repr(self->meta);
835     CPY_STRCAT_AND_DEL(&ret, tmp);
836   }
837   CPY_STRCAT(&ret, l_closing);
838   return ret;
839 }
840
841 static int Values_traverse(PyObject *self, visitproc visit, void *arg) {
842   Values *v = (Values *)self;
843   Py_VISIT(v->values);
844   Py_VISIT(v->meta);
845   return 0;
846 }
847
848 static int Values_clear(PyObject *self) {
849   Values *v = (Values *)self;
850   Py_CLEAR(v->values);
851   Py_CLEAR(v->meta);
852   return 0;
853 }
854
855 static void Values_dealloc(PyObject *self) {
856   Values_clear(self);
857   self->ob_type->tp_free(self);
858 }
859
860 static PyMemberDef Values_members[] = {
861     {"interval", T_DOUBLE, offsetof(Values, interval), 0, interval_doc},
862     {"values", T_OBJECT_EX, offsetof(Values, values), 0, values_doc},
863     {"meta", T_OBJECT_EX, offsetof(Values, meta), 0, meta_doc},
864     {NULL}};
865
866 static PyMethodDef Values_methods[] = {
867     {"dispatch", (PyCFunction)Values_dispatch, METH_VARARGS | METH_KEYWORDS,
868      dispatch_doc},
869     {"write", (PyCFunction)Values_write, METH_VARARGS | METH_KEYWORDS,
870      write_doc},
871     {NULL}};
872
873 PyTypeObject ValuesType = {
874     CPY_INIT_TYPE "collectd.Values", /* tp_name */
875     sizeof(Values),                  /* tp_basicsize */
876     0,                               /* Will be filled in later */
877     Values_dealloc,                  /* tp_dealloc */
878     0,                               /* tp_print */
879     0,                               /* tp_getattr */
880     0,                               /* tp_setattr */
881     0,                               /* tp_compare */
882     Values_repr,                     /* tp_repr */
883     0,                               /* tp_as_number */
884     0,                               /* tp_as_sequence */
885     0,                               /* tp_as_mapping */
886     0,                               /* tp_hash */
887     0,                               /* tp_call */
888     0,                               /* tp_str */
889     0,                               /* tp_getattro */
890     0,                               /* tp_setattro */
891     0,                               /* tp_as_buffer */
892     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, /*tp_flags*/
893     Values_doc,                                                    /* tp_doc */
894     Values_traverse, /* tp_traverse */
895     Values_clear,    /* tp_clear */
896     0,               /* tp_richcompare */
897     0,               /* tp_weaklistoffset */
898     0,               /* tp_iter */
899     0,               /* tp_iternext */
900     Values_methods,  /* tp_methods */
901     Values_members,  /* tp_members */
902     0,               /* tp_getset */
903     0,               /* tp_base */
904     0,               /* tp_dict */
905     0,               /* tp_descr_get */
906     0,               /* tp_descr_set */
907     0,               /* tp_dictoffset */
908     Values_init,     /* tp_init */
909     0,               /* tp_alloc */
910     Values_new       /* tp_new */
911 };
912
913 static char severity_doc[] =
914     "The severity of this notification. Assign or compare to\n"
915     "NOTIF_FAILURE, NOTIF_WARNING or NOTIF_OKAY.";
916
917 static char message_doc[] = "Some kind of description what's going on and why "
918                             "this Notification was generated.";
919
920 static char Notification_doc[] =
921     "The Notification class is a wrapper around the collectd notification.\n"
922     "It can be used to notify other plugins about bad stuff happening. It "
923     "works\n"
924     "similar to Values but has a severity and a message instead of interval\n"
925     "and time.\n"
926     "Notifications can be dispatched at any time and can be received with "
927     "register_notification.";
928
929 static int Notification_init(PyObject *s, PyObject *args, PyObject *kwds) {
930   Notification *self = (Notification *)s;
931   int severity = 0;
932   double time = 0;
933   char *message = NULL;
934   char *type = NULL, *plugin_instance = NULL, *type_instance = NULL,
935        *plugin = NULL, *host = NULL;
936   static char *kwlist[] = {"type",          "message",  "plugin_instance",
937                            "type_instance", "plugin",   "host",
938                            "time",          "severity", NULL};
939
940   if (!PyArg_ParseTupleAndKeywords(args, kwds, "|etetetetetetdi", kwlist, NULL,
941                                    &type, NULL, &message, NULL,
942                                    &plugin_instance, NULL, &type_instance, NULL,
943                                    &plugin, NULL, &host, &time, &severity))
944     return -1;
945
946   if (type && plugin_get_ds(type) == NULL) {
947     PyErr_Format(PyExc_TypeError, "Dataset %s not found", type);
948     FreeAll();
949     PyMem_Free(message);
950     return -1;
951   }
952
953   sstrncpy(self->data.host, host ? host : "", sizeof(self->data.host));
954   sstrncpy(self->data.plugin, plugin ? plugin : "", sizeof(self->data.plugin));
955   sstrncpy(self->data.plugin_instance, plugin_instance ? plugin_instance : "",
956            sizeof(self->data.plugin_instance));
957   sstrncpy(self->data.type, type ? type : "", sizeof(self->data.type));
958   sstrncpy(self->data.type_instance, type_instance ? type_instance : "",
959            sizeof(self->data.type_instance));
960   sstrncpy(self->message, message ? message : "", sizeof(self->message));
961   self->data.time = time;
962   self->severity = severity;
963
964   FreeAll();
965   PyMem_Free(message);
966   return 0;
967 }
968
969 static PyObject *Notification_dispatch(Notification *self, PyObject *args,
970                                        PyObject *kwds) {
971   int ret;
972   const data_set_t *ds;
973   notification_t notification;
974   double t = self->data.time;
975   int severity = self->severity;
976   char *host = NULL, *plugin = NULL, *plugin_instance = NULL, *type = NULL,
977        *type_instance = NULL;
978   char *message = NULL;
979
980   static char *kwlist[] = {"type",          "message",  "plugin_instance",
981                            "type_instance", "plugin",   "host",
982                            "time",          "severity", NULL};
983   if (!PyArg_ParseTupleAndKeywords(args, kwds, "|etetetetetetdi", kwlist, NULL,
984                                    &type, NULL, &message, NULL,
985                                    &plugin_instance, NULL, &type_instance, NULL,
986                                    &plugin, NULL, &host, &t, &severity))
987     return NULL;
988
989   notification.time = DOUBLE_TO_CDTIME_T(t);
990   notification.severity = severity;
991   sstrncpy(notification.message, message ? message : self->message,
992            sizeof(notification.message));
993   sstrncpy(notification.host, host ? host : self->data.host,
994            sizeof(notification.host));
995   sstrncpy(notification.plugin, plugin ? plugin : self->data.plugin,
996            sizeof(notification.plugin));
997   sstrncpy(notification.plugin_instance,
998            plugin_instance ? plugin_instance : self->data.plugin_instance,
999            sizeof(notification.plugin_instance));
1000   sstrncpy(notification.type, type ? type : self->data.type,
1001            sizeof(notification.type));
1002   sstrncpy(notification.type_instance,
1003            type_instance ? type_instance : self->data.type_instance,
1004            sizeof(notification.type_instance));
1005   notification.meta = NULL;
1006   FreeAll();
1007   PyMem_Free(message);
1008
1009   if (notification.type[0] == 0) {
1010     PyErr_SetString(PyExc_RuntimeError, "type not set");
1011     return NULL;
1012   }
1013   ds = plugin_get_ds(notification.type);
1014   if (ds == NULL) {
1015     PyErr_Format(PyExc_TypeError, "Dataset %s not found", notification.type);
1016     return NULL;
1017   }
1018
1019   if (notification.time == 0)
1020     notification.time = cdtime();
1021   if (notification.host[0] == 0)
1022     sstrncpy(notification.host, hostname_g, sizeof(notification.host));
1023   if (notification.plugin[0] == 0)
1024     sstrncpy(notification.plugin, "python", sizeof(notification.plugin));
1025   Py_BEGIN_ALLOW_THREADS;
1026   ret = plugin_dispatch_notification(&notification);
1027   Py_END_ALLOW_THREADS;
1028   if (ret != 0) {
1029     PyErr_SetString(PyExc_RuntimeError,
1030                     "error dispatching notification, read the logs");
1031     return NULL;
1032   }
1033   Py_RETURN_NONE;
1034 }
1035
1036 static PyObject *Notification_new(PyTypeObject *type, PyObject *args,
1037                                   PyObject *kwds) {
1038   Notification *self;
1039
1040   self = (Notification *)PluginData_new(type, args, kwds);
1041   if (self == NULL)
1042     return NULL;
1043
1044   self->message[0] = 0;
1045   self->severity = 0;
1046   return (PyObject *)self;
1047 }
1048
1049 static int Notification_setstring(PyObject *self, PyObject *value, void *data) {
1050   char *old;
1051   const char *new;
1052
1053   if (value == NULL) {
1054     PyErr_SetString(PyExc_TypeError, "Cannot delete this attribute");
1055     return -1;
1056   }
1057   Py_INCREF(value);
1058   new = cpy_unicode_or_bytes_to_string(&value);
1059   if (new == NULL) {
1060     Py_DECREF(value);
1061     return -1;
1062   }
1063   old = ((char *)self) + (intptr_t)data;
1064   sstrncpy(old, new, NOTIF_MAX_MSG_LEN);
1065   Py_DECREF(value);
1066   return 0;
1067 }
1068
1069 static PyObject *Notification_repr(PyObject *s) {
1070   PyObject *ret, *tmp;
1071   static PyObject *l_severity = NULL, *l_message = NULL, *l_closing = NULL;
1072   Notification *self = (Notification *)s;
1073
1074   if (l_severity == NULL)
1075     l_severity = cpy_string_to_unicode_or_bytes(",severity=");
1076   if (l_message == NULL)
1077     l_message = cpy_string_to_unicode_or_bytes(",message=");
1078   if (l_closing == NULL)
1079     l_closing = cpy_string_to_unicode_or_bytes(")");
1080
1081   if (l_severity == NULL || l_message == NULL || l_closing == NULL)
1082     return NULL;
1083
1084   ret = cpy_common_repr(s);
1085   if (self->severity != 0) {
1086     CPY_STRCAT(&ret, l_severity);
1087     tmp = PyInt_FromLong(self->severity);
1088     CPY_SUBSTITUTE(PyObject_Repr, tmp, tmp);
1089     CPY_STRCAT_AND_DEL(&ret, tmp);
1090   }
1091   if (self->message[0] != 0) {
1092     CPY_STRCAT(&ret, l_message);
1093     tmp = cpy_string_to_unicode_or_bytes(self->message);
1094     CPY_SUBSTITUTE(PyObject_Repr, tmp, tmp);
1095     CPY_STRCAT_AND_DEL(&ret, tmp);
1096   }
1097   CPY_STRCAT(&ret, l_closing);
1098   return ret;
1099 }
1100
1101 static PyMethodDef Notification_methods[] = {
1102     {"dispatch", (PyCFunction)Notification_dispatch,
1103      METH_VARARGS | METH_KEYWORDS, dispatch_doc},
1104     {NULL}};
1105
1106 static PyMemberDef Notification_members[] = {
1107     {"severity", T_INT, offsetof(Notification, severity), 0, severity_doc},
1108     {NULL}};
1109
1110 static PyGetSetDef Notification_getseters[] = {
1111     {"message", PluginData_getstring, Notification_setstring, message_doc,
1112      (void *)offsetof(Notification, message)},
1113     {NULL}};
1114
1115 PyTypeObject NotificationType = {
1116     CPY_INIT_TYPE "collectd.Notification",    /* tp_name */
1117     sizeof(Notification),                     /* tp_basicsize */
1118     0,                                        /* Will be filled in later */
1119     0,                                        /* tp_dealloc */
1120     0,                                        /* tp_print */
1121     0,                                        /* tp_getattr */
1122     0,                                        /* tp_setattr */
1123     0,                                        /* tp_compare */
1124     Notification_repr,                        /* tp_repr */
1125     0,                                        /* tp_as_number */
1126     0,                                        /* tp_as_sequence */
1127     0,                                        /* tp_as_mapping */
1128     0,                                        /* tp_hash */
1129     0,                                        /* tp_call */
1130     0,                                        /* tp_str */
1131     0,                                        /* tp_getattro */
1132     0,                                        /* tp_setattro */
1133     0,                                        /* tp_as_buffer */
1134     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
1135     Notification_doc,                         /* tp_doc */
1136     0,                                        /* tp_traverse */
1137     0,                                        /* tp_clear */
1138     0,                                        /* tp_richcompare */
1139     0,                                        /* tp_weaklistoffset */
1140     0,                                        /* tp_iter */
1141     0,                                        /* tp_iternext */
1142     Notification_methods,                     /* tp_methods */
1143     Notification_members,                     /* tp_members */
1144     Notification_getseters,                   /* tp_getset */
1145     0,                                        /* tp_base */
1146     0,                                        /* tp_dict */
1147     0,                                        /* tp_descr_get */
1148     0,                                        /* tp_descr_set */
1149     0,                                        /* tp_dictoffset */
1150     Notification_init,                        /* tp_init */
1151     0,                                        /* tp_alloc */
1152     Notification_new                          /* tp_new */
1153 };
1154
1155 static char Signed_doc[] =
1156     "This is a long by another name. Use it in meta data dicts\n"
1157     "to choose the way it is stored in the meta data.";
1158
1159 PyTypeObject SignedType = {
1160     CPY_INIT_TYPE "collectd.Signed",          /* tp_name */
1161     sizeof(Signed),                           /* tp_basicsize */
1162     0,                                        /* Will be filled in later */
1163     0,                                        /* tp_dealloc */
1164     0,                                        /* tp_print */
1165     0,                                        /* tp_getattr */
1166     0,                                        /* tp_setattr */
1167     0,                                        /* tp_compare */
1168     0,                                        /* tp_repr */
1169     0,                                        /* tp_as_number */
1170     0,                                        /* tp_as_sequence */
1171     0,                                        /* tp_as_mapping */
1172     0,                                        /* tp_hash */
1173     0,                                        /* tp_call */
1174     0,                                        /* tp_str */
1175     0,                                        /* tp_getattro */
1176     0,                                        /* tp_setattro */
1177     0,                                        /* tp_as_buffer */
1178     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
1179     Signed_doc                                /* tp_doc */
1180 };
1181
1182 static char Unsigned_doc[] =
1183     "This is a long by another name. Use it in meta data dicts\n"
1184     "to choose the way it is stored in the meta data.";
1185
1186 PyTypeObject UnsignedType = {
1187     CPY_INIT_TYPE "collectd.Unsigned",        /* tp_name */
1188     sizeof(Unsigned),                         /* tp_basicsize */
1189     0,                                        /* Will be filled in later */
1190     0,                                        /* tp_dealloc */
1191     0,                                        /* tp_print */
1192     0,                                        /* tp_getattr */
1193     0,                                        /* tp_setattr */
1194     0,                                        /* tp_compare */
1195     0,                                        /* tp_repr */
1196     0,                                        /* tp_as_number */
1197     0,                                        /* tp_as_sequence */
1198     0,                                        /* tp_as_mapping */
1199     0,                                        /* tp_hash */
1200     0,                                        /* tp_call */
1201     0,                                        /* tp_str */
1202     0,                                        /* tp_getattro */
1203     0,                                        /* tp_setattro */
1204     0,                                        /* tp_as_buffer */
1205     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
1206     Unsigned_doc                              /* tp_doc */
1207 };