e57970eabf904e0d5380de7d56b17e075acb8628
[collecty.git] / src / _collectymodule.c
1 /*
2  * collecty
3  * Copyright (C) 2015 IPFire Team (www.ipfire.org)
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 3 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
17  */
18
19 #include <Python.h>
20
21 #include <atasmart.h>
22 #include <errno.h>
23 #include <fcntl.h>
24 #include <linux/hdreg.h>
25 #include <sensors/error.h>
26 #include <sensors/sensors.h>
27 #include <stdbool.h>
28 #include <string.h>
29 #include <sys/ioctl.h>
30
31 #define MODEL_SIZE  40
32 #define SERIAL_SIZE 20
33
34 typedef struct {
35         PyObject_HEAD
36         char* path;
37         struct hd_driveid identity;
38         SkDisk* disk;
39 } BlockDevice;
40
41 static void BlockDevice_dealloc(BlockDevice* self) {
42         if (self->disk)
43                 sk_disk_free(self->disk);
44
45         if (self->path)
46                 free(self->path);
47
48         self->ob_type->tp_free((PyObject*)self);
49 }
50
51 static int BlockDevice_get_identity(BlockDevice* device) {
52         int fd;
53
54         if ((fd = open(device->path, O_RDONLY | O_NONBLOCK)) < 0) {
55                 return 1;
56         }
57
58         int r = ioctl(fd, HDIO_GET_IDENTITY, &device->identity);
59         close(fd);
60
61         if (r)
62                 return 1;
63
64         return 0;
65 }
66
67 static int BlockDevice_smart_is_available(BlockDevice* device) {
68         SkBool available = FALSE;
69
70         int r = sk_disk_smart_is_available(device->disk, &available);
71         if (r)
72                 return -1;
73
74         if (available)
75                 return 0;
76
77         return 1;
78 }
79
80 static int BlockDevice_check_sleep_mode(BlockDevice* device) {
81         SkBool awake = FALSE;
82
83         int r = sk_disk_check_sleep_mode(device->disk, &awake);
84         if (r)
85                 return -1;
86
87         if (awake)
88                 return 0;
89
90         return 1;
91 }
92
93 static PyObject * BlockDevice_new(PyTypeObject* type, PyObject* args, PyObject* kwds) {
94         BlockDevice* self = (BlockDevice*)type->tp_alloc(type, 0);
95
96         if (self) {
97                 self->path = NULL;
98
99                 // libatasmart
100                 self->disk = NULL;
101         }
102
103         return (PyObject *)self;
104 }
105
106 static int BlockDevice_init(BlockDevice* self, PyObject* args, PyObject* kwds) {
107         const char* path = NULL;
108
109         if (!PyArg_ParseTuple(args, "s", &path))
110                 return -1;
111
112         self->path = strdup(path);
113
114         int r = BlockDevice_get_identity(self);
115         if (r) {
116                 PyErr_Format(PyExc_OSError, "Could not open block device: %s", path);
117                 return -1;
118         }
119
120         r = sk_disk_open(path, &self->disk);
121         if (r == 0) {
122                 if (BlockDevice_smart_is_available(self) == 0) {
123                         if (BlockDevice_check_sleep_mode(self) == 0) {
124                                 r = sk_disk_smart_read_data(self->disk);
125                                 if (r) {
126                                         PyErr_Format(PyExc_OSError, "Could not open block device %s: %s", path,
127                                                 strerror(errno));
128                                         return -1;
129                                 }
130                         }
131                 }
132         } else {
133                 PyErr_Format(PyExc_OSError, "Could not open block device %s: %s", path,
134                         strerror(errno));
135                 return -1;
136         }
137
138         //sk_disk_identify_is_available
139
140         return 0;
141 }
142
143 static PyObject* BlockDevice_get_path(PyObject* self) {
144         BlockDevice* device = (BlockDevice*)self;
145
146         return PyString_FromString(device->path);
147 }
148
149 static void clean_string(char *s) {
150         for (char* e = s; *e; e++) {
151                 if (*e < ' ' || *e >= 127)
152                         *e = ' ';
153         }
154 }
155
156 static void drop_spaces(char *s) {
157         char *d = s;
158         bool prev_space = false;
159
160         s += strspn(s, " ");
161
162         for (; *s; s++) {
163                 if (prev_space) {
164                         if (*s != ' ') {
165                                 prev_space = false;
166                                 *(d++) = ' ';
167                                 *(d++) = *s;
168                         }
169                 } else {
170                         if (*s == ' ')
171                                 prev_space = true;
172                         else
173                                 *(d++) = *s;
174                 }
175         }
176
177         *d = 0;
178 }
179
180 static void copy_string(char* d, const char* s, size_t n) {
181         // Copy the source buffer to the destination buffer up to n
182         memcpy(d, s, n);
183
184         // Terminate the destination buffer with NULL
185         d[n] = '\0';
186
187         // Clean up the string from non-printable characters
188         clean_string(d);
189         drop_spaces(d);
190 }
191
192 static PyObject* BlockDevice_get_model(PyObject* self) {
193         BlockDevice* device = (BlockDevice*)self;
194
195         char model[MODEL_SIZE + 1];
196         copy_string(model, device->identity.model, sizeof(model));
197
198         return PyString_FromString(model);
199 }
200
201 static PyObject* BlockDevice_get_serial(PyObject* self) {
202         BlockDevice* device = (BlockDevice*)self;
203
204         char serial[SERIAL_SIZE + 1];
205         copy_string(serial, device->identity.serial_no, sizeof(serial));
206
207         return PyString_FromString(serial);
208 }
209
210 static PyObject* BlockDevice_is_smart_supported(PyObject* self) {
211         BlockDevice* device = (BlockDevice*)self;
212
213         if (BlockDevice_smart_is_available(device) == 0)
214                 Py_RETURN_TRUE;
215
216         Py_RETURN_FALSE;
217 }
218
219 static PyObject* BlockDevice_is_awake(PyObject* self) {
220         BlockDevice* device = (BlockDevice*)self;
221
222         if (BlockDevice_check_sleep_mode(device) == 0)
223                 Py_RETURN_TRUE;
224
225         Py_RETURN_FALSE;
226 }
227
228 static PyObject* BlockDevice_get_bad_sectors(PyObject* self) {
229         BlockDevice* device = (BlockDevice*)self;
230
231         if (BlockDevice_smart_is_available(device)) {
232                 PyErr_Format(PyExc_OSError, "Device does not support SMART");
233                 return NULL;
234         }
235
236         uint64_t bad_sectors;
237         int r = sk_disk_smart_get_bad(device->disk, &bad_sectors);
238         if (r)
239                 return NULL;
240
241         return PyLong_FromUnsignedLongLong((unsigned long long)bad_sectors);
242 }
243
244 static PyObject* BlockDevice_get_temperature(PyObject* self) {
245         BlockDevice* device = (BlockDevice*)self;
246
247         if (BlockDevice_smart_is_available(device)) {
248                 PyErr_Format(PyExc_OSError, "Device does not support SMART");
249                 return NULL;
250         }
251
252         uint64_t mkelvin;
253         int r = sk_disk_smart_get_temperature(device->disk, &mkelvin);
254         if (r)
255                 return NULL;
256
257         // Convert the temperature to Kelvin
258         return PyFloat_FromDouble((double)mkelvin / 1000.0);
259 }
260
261 static PyGetSetDef BlockDevice_getsetters[] = {
262         {"path", (getter)BlockDevice_get_path, NULL, NULL, NULL},
263         {"model", (getter)BlockDevice_get_model, NULL, NULL, NULL},
264         {"serial", (getter)BlockDevice_get_serial, NULL, NULL, NULL},
265 };
266
267 static PyMethodDef BlockDevice_methods[] = {
268         {"get_bad_sectors", (PyCFunction)BlockDevice_get_bad_sectors, METH_NOARGS, NULL},
269         {"get_temperature", (PyCFunction)BlockDevice_get_temperature, METH_NOARGS, NULL},
270         {"is_smart_supported", (PyCFunction)BlockDevice_is_smart_supported, METH_NOARGS, NULL},
271         {"is_awake", (PyCFunction)BlockDevice_is_awake, METH_NOARGS, NULL},
272         {NULL}
273 };
274
275 static PyTypeObject BlockDeviceType = {
276         PyObject_HEAD_INIT(NULL)
277         0,                                  /*ob_size*/
278         "_collecty.BlockDevice",            /*tp_name*/
279         sizeof(BlockDevice),                /*tp_basicsize*/
280         0,                                  /*tp_itemsize*/
281         (destructor)BlockDevice_dealloc,    /*tp_dealloc*/
282         0,                                  /*tp_print*/
283         0,                                  /*tp_getattr*/
284         0,                                  /*tp_setattr*/
285         0,                                  /*tp_compare*/
286         0,                                  /*tp_repr*/
287         0,                                  /*tp_as_number*/
288         0,                                  /*tp_as_sequence*/
289         0,                                  /*tp_as_mapping*/
290         0,                                  /*tp_hash */
291         0,                                  /*tp_call*/
292         0,                                  /*tp_str*/
293         0,                                  /*tp_getattro*/
294         0,                                  /*tp_setattro*/
295         0,                                  /*tp_as_buffer*/
296         Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /*tp_flags*/
297         "BlockDevice objects",              /* tp_doc */
298         0,                                          /* tp_traverse */
299         0,                                          /* tp_clear */
300         0,                                          /* tp_richcompare */
301         0,                                          /* tp_weaklistoffset */
302         0,                                          /* tp_iter */
303         0,                                          /* tp_iternext */
304         BlockDevice_methods,                /* tp_methods */
305         0,                                  /* tp_members */
306         BlockDevice_getsetters,             /* tp_getset */
307         0,                                  /* tp_base */
308         0,                                  /* tp_dict */
309         0,                                  /* tp_descr_get */
310         0,                                  /* tp_descr_set */
311         0,                                  /* tp_dictoffset */
312         (initproc)BlockDevice_init,         /* tp_init */
313         0,                                  /* tp_alloc */
314         BlockDevice_new,                    /* tp_new */
315 };
316
317 typedef struct {
318         PyObject_HEAD
319         const sensors_chip_name* chip;
320         const sensors_feature* feature;
321 } SensorObject;
322
323 static void Sensor_dealloc(SensorObject* self) {
324         self->ob_type->tp_free((PyObject*)self);
325 }
326
327 static PyObject* Sensor_new(PyTypeObject* type, PyObject* args, PyObject* kwds) {
328         SensorObject* self = (SensorObject*)type->tp_alloc(type, 0);
329
330         return (PyObject *)self;
331 }
332
333 static int Sensor_init(SensorObject* self, PyObject* args, PyObject* kwds) {
334         return 0;
335 }
336
337 static PyObject* Sensor_get_label(SensorObject* self) {
338         char* label = sensors_get_label(self->chip, self->feature);
339
340         if (label) {
341                 PyObject* string = PyString_FromString(label);
342                 free(label);
343
344                 return string;
345         }
346
347         Py_RETURN_NONE;
348 }
349
350 static PyObject* Sensor_get_name(SensorObject* self) {
351         char chip_name[512];
352
353         int r = sensors_snprintf_chip_name(chip_name, sizeof(chip_name), self->chip);
354         if (r < 0) {
355                 PyErr_Format(PyExc_RuntimeError, "Could not print chip name");
356                 return NULL;
357         }
358
359         return PyString_FromString(chip_name);
360 }
361
362 static PyObject* Sensor_get_type(SensorObject* self) {
363         const char* type = NULL;
364
365         switch (self->feature->type) {
366                 case SENSORS_FEATURE_IN:
367                         type = "voltage";
368                         break;
369
370                 case SENSORS_FEATURE_FAN:
371                         type = "fan";
372                         break;
373
374                 case SENSORS_FEATURE_TEMP:
375                         type = "temperature";
376                         break;
377
378                 case SENSORS_FEATURE_POWER:
379                         type = "power";
380                         break;
381
382                 default:
383                         break;
384         }
385
386         if (type)
387                 return PyString_FromString(type);
388
389         Py_RETURN_NONE;
390 }
391
392 static PyObject* Sensor_get_bus(SensorObject* self) {
393         const char* type = NULL;
394
395         switch (self->chip->bus.type) {
396                 case SENSORS_BUS_TYPE_I2C:
397                         type = "i2c";
398                         break;
399
400                 case SENSORS_BUS_TYPE_ISA:
401                         type = "isa";
402                         break;
403
404                 case SENSORS_BUS_TYPE_PCI:
405                         type = "pci";
406                         break;
407
408                 case SENSORS_BUS_TYPE_SPI:
409                         type = "spi";
410                         break;
411
412                 case SENSORS_BUS_TYPE_VIRTUAL:
413                         type = "virtual";
414                         break;
415
416                 case SENSORS_BUS_TYPE_ACPI:
417                         type = "acpi";
418                         break;
419
420                 case SENSORS_BUS_TYPE_HID:
421                         type = "hid";
422                         break;
423
424                 default:
425                         break;
426         }
427
428         if (type)
429                 return PyString_FromString(type);
430
431         Py_RETURN_NONE;
432 }
433
434 static const sensors_subfeature* Sensor_get_subfeature(SensorObject* sensor, sensors_subfeature_type type) {
435         const sensors_subfeature* subfeature;
436         int subfeature_num = 0;
437
438         while ((subfeature = sensors_get_all_subfeatures(sensor->chip, sensor->feature, &subfeature_num))) {
439                 if (subfeature->type == type)
440                         break;
441         }
442
443         return subfeature;
444 }
445
446 static PyObject* Sensor_return_value(SensorObject* sensor, sensors_subfeature_type subfeature_type) {
447         double value;
448
449         const sensors_subfeature* subfeature = Sensor_get_subfeature(sensor, subfeature_type);
450         if (!subfeature) {
451                 PyErr_Format(PyExc_AttributeError, "Could not find sensor of requested type");
452                 return NULL;
453         }
454
455         // Fetch value from the sensor
456         int r = sensors_get_value(sensor->chip, subfeature->number, &value);
457         if (r < 0) {
458                 PyErr_Format(PyExc_ValueError, "Error retrieving value from sensor: %s",
459                         sensors_strerror(errno));
460                 return NULL;
461         }
462
463         // Convert all temperature values from Celcius to Kelvon
464         if (sensor->feature->type == SENSORS_FEATURE_TEMP)
465                 value += 273.15;
466
467         return PyFloat_FromDouble(value);
468 }
469
470 static PyObject* Sensor_no_value() {
471         PyErr_Format(PyExc_ValueError, "Value not supported for this sensor type");
472         return NULL;
473 }
474
475 static PyObject* Sensor_get_value(SensorObject* self) {
476         sensors_subfeature_type subfeature_type;
477
478         switch (self->feature->type) {
479                 case SENSORS_FEATURE_IN:
480                         subfeature_type = SENSORS_SUBFEATURE_IN_INPUT;
481                         break;
482
483                 case SENSORS_FEATURE_FAN:
484                         subfeature_type = SENSORS_SUBFEATURE_FAN_INPUT;
485                         break;
486
487                 case SENSORS_FEATURE_TEMP:
488                         subfeature_type = SENSORS_SUBFEATURE_TEMP_INPUT;
489                         break;
490
491                 case SENSORS_FEATURE_POWER:
492                         subfeature_type = SENSORS_SUBFEATURE_POWER_INPUT;
493                         break;
494
495                 default:
496                         return Sensor_no_value();
497         }
498
499         return Sensor_return_value(self, subfeature_type);
500 }
501
502 static PyObject* Sensor_get_critical(SensorObject* self) {
503         sensors_subfeature_type subfeature_type;
504
505         switch (self->feature->type) {
506                 case SENSORS_FEATURE_IN:
507                         subfeature_type = SENSORS_SUBFEATURE_IN_CRIT;
508                         break;
509
510                 case SENSORS_FEATURE_TEMP:
511                         subfeature_type = SENSORS_SUBFEATURE_TEMP_CRIT;
512                         break;
513
514                 case SENSORS_FEATURE_POWER:
515                         subfeature_type = SENSORS_SUBFEATURE_POWER_CRIT;
516                         break;
517
518                 default:
519                         return Sensor_no_value();
520         }
521
522         return Sensor_return_value(self, subfeature_type);
523 }
524
525 static PyObject* Sensor_get_maximum(SensorObject* self) {
526         sensors_subfeature_type subfeature_type;
527
528         switch (self->feature->type) {
529                 case SENSORS_FEATURE_IN:
530                         subfeature_type = SENSORS_SUBFEATURE_IN_MAX;
531                         break;
532
533                 case SENSORS_FEATURE_FAN:
534                         subfeature_type = SENSORS_SUBFEATURE_FAN_MAX;
535                         break;
536
537                 case SENSORS_FEATURE_TEMP:
538                         subfeature_type = SENSORS_SUBFEATURE_TEMP_MAX;
539                         break;
540
541                 case SENSORS_FEATURE_POWER:
542                         subfeature_type = SENSORS_SUBFEATURE_POWER_MAX;
543                         break;
544
545                 default:
546                         return Sensor_no_value();
547         }
548
549         return Sensor_return_value(self, subfeature_type);
550 }
551
552 static PyObject* Sensor_get_minimum(SensorObject* self) {
553         sensors_subfeature_type subfeature_type;
554
555         switch (self->feature->type) {
556                 case SENSORS_FEATURE_IN:
557                         subfeature_type = SENSORS_SUBFEATURE_IN_MIN;
558                         break;
559
560                 case SENSORS_FEATURE_FAN:
561                         subfeature_type = SENSORS_SUBFEATURE_FAN_MIN;
562                         break;
563
564                 case SENSORS_FEATURE_TEMP:
565                         subfeature_type = SENSORS_SUBFEATURE_TEMP_MIN;
566                         break;
567
568                 default:
569                         return Sensor_no_value();
570         }
571
572         return Sensor_return_value(self, subfeature_type);
573 }
574
575 static PyObject* Sensor_get_high(SensorObject* self) {
576         sensors_subfeature_type subfeature_type;
577
578         switch (self->feature->type) {
579                 case SENSORS_FEATURE_TEMP:
580                         subfeature_type = SENSORS_SUBFEATURE_TEMP_MAX;
581                         break;
582
583                 default:
584                         return Sensor_no_value();
585         }
586
587         return Sensor_return_value(self, subfeature_type);
588 }
589
590 static PyGetSetDef Sensor_getsetters[] = {
591         {"bus", (getter)Sensor_get_bus, NULL, NULL, NULL},
592         {"critical", (getter)Sensor_get_critical, NULL, NULL, NULL},
593         {"high", (getter)Sensor_get_high, NULL, NULL, NULL},
594         {"label", (getter)Sensor_get_label, NULL, NULL, NULL},
595         {"maximum", (getter)Sensor_get_maximum, NULL, NULL, NULL},
596         {"minumum", (getter)Sensor_get_minimum, NULL, NULL, NULL},
597         {"name", (getter)Sensor_get_name, NULL, NULL, NULL},
598         {"type", (getter)Sensor_get_type, NULL, NULL, NULL},
599         {"value", (getter)Sensor_get_value, NULL, NULL, NULL},
600         {NULL},
601 };
602
603 static PyTypeObject SensorType = {
604         PyObject_HEAD_INIT(NULL)
605         0,                                  /*ob_size*/
606         "_collecty.Sensor",                 /*tp_name*/
607         sizeof(SensorObject),               /*tp_basicsize*/
608         0,                                  /*tp_itemsize*/
609         (destructor)Sensor_dealloc,         /*tp_dealloc*/
610         0,                                  /*tp_print*/
611         0,                                  /*tp_getattr*/
612         0,                                  /*tp_setattr*/
613         0,                                  /*tp_compare*/
614         0,                                  /*tp_repr*/
615         0,                                  /*tp_as_number*/
616         0,                                  /*tp_as_sequence*/
617         0,                                  /*tp_as_mapping*/
618         0,                                  /*tp_hash */
619         0,                                  /*tp_call*/
620         0,                                  /*tp_str*/
621         0,                                  /*tp_getattro*/
622         0,                                  /*tp_setattro*/
623         0,                                  /*tp_as_buffer*/
624         Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /*tp_flags*/
625         "Sensor objects",                   /* tp_doc */
626         0,                                  /* tp_traverse */
627         0,                                  /* tp_clear */
628         0,                                  /* tp_richcompare */
629         0,                                  /* tp_weaklistoffset */
630         0,                                  /* tp_iter */
631         0,                                  /* tp_iternext */
632         0,                                  /* tp_methods */
633         0,                                  /* tp_members */
634         Sensor_getsetters,                  /* tp_getset */
635         0,                                  /* tp_base */
636         0,                                  /* tp_dict */
637         0,                                  /* tp_descr_get */
638         0,                                  /* tp_descr_set */
639         0,                                  /* tp_dictoffset */
640         (initproc)Sensor_init,              /* tp_init */
641         0,                                  /* tp_alloc */
642         Sensor_new,                         /* tp_new */
643 };
644
645 static SensorObject* make_sensor_object(const sensors_chip_name* chip, const sensors_feature* feature) {
646         SensorObject* sensor = PyObject_New(SensorObject, &SensorType);
647         if (!sensor)
648                 return NULL;
649
650         if (!PyObject_Init((PyObject*)sensor, &SensorType)) {
651                 Py_DECREF(sensor);
652                 return NULL;
653         }
654
655         sensor->chip = chip;
656         sensor->feature = feature;
657
658         return sensor;
659 }
660
661 static PyObject* _collecty_sensors_init() {
662         // Clean up everything first in case sensors_init was called earlier
663         sensors_cleanup();
664
665         int r = sensors_init(NULL);
666         if (r) {
667                 PyErr_Format(PyExc_OSError, "Could not initialise sensors: %s",
668                         sensors_strerror(errno));
669                 return NULL;
670         }
671
672         Py_RETURN_NONE;
673 }
674
675 static PyObject* _collecty_sensors_cleanup() {
676         sensors_cleanup();
677         Py_RETURN_NONE;
678 }
679
680 static PyObject* _collecty_get_detected_sensors(PyObject* o, PyObject* args) {
681         const char* name = NULL;
682         sensors_chip_name chip_name;
683
684         if (!PyArg_ParseTuple(args, "|z", &name))
685                 return NULL;
686
687         if (name) {
688                 int r = sensors_parse_chip_name(name, &chip_name);
689                 if (r < 0) {
690                         PyErr_Format(PyExc_ValueError, "Could not parse chip name: %s", name);
691                         return NULL;
692                 }
693         }
694
695         PyObject* list = PyList_New(0);
696
697         const sensors_chip_name* chip;
698         int chip_num = 0;
699
700         while ((chip = sensors_get_detected_chips((name) ? &chip_name : NULL, &chip_num))) {
701                 const sensors_feature* feature;
702                 int feature_num = 0;
703
704                 while ((feature = sensors_get_features(chip, &feature_num))) {
705                         // Skip sensors we do not want to support
706                         switch (feature->type) {
707                                 case SENSORS_FEATURE_IN:
708                                 case SENSORS_FEATURE_FAN:
709                                 case SENSORS_FEATURE_TEMP:
710                                 case SENSORS_FEATURE_POWER:
711                                         break;
712
713                                 default:
714                                         continue;
715                         }
716
717                         SensorObject* sensor = make_sensor_object(chip, feature);
718                         PyList_Append(list, (PyObject*)sensor);
719                 }
720         }
721
722         return list;
723 }
724
725 static PyMethodDef collecty_module_methods[] = {
726         {"get_detected_sensors", (PyCFunction)_collecty_get_detected_sensors, METH_VARARGS, NULL},
727         {"sensors_cleanup", (PyCFunction)_collecty_sensors_cleanup, METH_NOARGS, NULL},
728         {"sensors_init", (PyCFunction)_collecty_sensors_init, METH_NOARGS, NULL},
729         {NULL},
730 };
731
732 void init_collecty(void) {
733         if (PyType_Ready(&BlockDeviceType) < 0)
734                 return;
735
736         if (PyType_Ready(&SensorType) < 0)
737                 return;
738
739         PyObject* m = Py_InitModule("_collecty", collecty_module_methods);
740
741         PyModule_AddObject(m, "BlockDevice", (PyObject*)&BlockDeviceType);
742         PyModule_AddObject(m, "Sensor", (PyObject*)&SensorType);
743 }