glib/pygsource.c

   1 /* -*- Mode: C; c-basic-offset: 4 -*-
   2  * pygtk- Python bindings for the GTK toolkit.
   3  * Copyright (C) 1998-2003  James Henstridge
   4  * Copyright (C) 2005       Oracle
   5  *
   6  * Author: Manish Singh <manish.singh@oracle.com>
   7  *
   8  *   pygsource.c: GSource wrapper
   9  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with this library; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
  23  * USA
  24  */
  25
  26 #ifdef HAVE_CONFIG_H
  27 #  include <config.h>
  28 #endif
  29
  30 #include <Python.h>
  31 #include <pythread.h>
  32 #include <structmember.h> /* for PyMemberDef */
  33 #include "pyglib.h"
  34 #include "pyglib-private.h"
  35 #include "pygmaincontext.h"
  36 #include "pygsource.h"
  37
  38 #define CHECK_DESTROYED(self, ret)                      G_STMT_START {  \
  39     if ((self)->source == NULL) {                                       \
  40         PyErr_SetString(PyExc_RuntimeError, "source is destroyed");     \
  41         return (ret);                                                   \
  42     }                                                                   \
  43 } G_STMT_END
  44
  45
  46 typedef struct {
  47     PyObject_HEAD
  48     GSource *source;
  49     PyObject *inst_dict;
  50     PyObject *weakreflist;
  51     gboolean python_source;
  52 } PyGSource;
  53
  54 typedef struct
  55 {
  56     GSource source;
  57     PyObject *obj;
  58 } PyGRealSource;
  59
  60 /* glib.Source */
  61
  62 PYGLIB_DEFINE_TYPE("glib.Source", PyGSource_Type, PyGSource)
  63
  64 static PyObject *
  65 source_repr(PyGSource *self, const char *type)
  66 {
  67     gchar buf[256], *desc;
  68
  69     if (self->source) {
  70         if (g_source_get_context(self->source))
  71             desc = "attached";
  72         else
  73             desc = "unattached";
  74     } else {
  75         desc = "destroyed";
  76     }
  77
  78     if (type)
  79         g_snprintf(buf, sizeof(buf), "<%s glib %s source at 0x%lx>",
  80                    desc, type, (long) self);
  81     else
  82         g_snprintf(buf, sizeof(buf), "<%s glib source at 0x%lx>",
  83                    desc, (long) self);
  84
  85     return _PyUnicode_FromString(buf);
  86 }
  87
  88 static PyObject *
  89 pyg_source_attach(PyGSource *self, PyObject *args, PyObject *kwargs)
  90 {
  91     static char *kwlist[] = { "context", NULL };
  92     PyGMainContext *py_context = NULL;
  93     GMainContext *context = NULL;
  94     guint id;
  95
  96     if (!PyArg_ParseTupleAndKeywords (args, kwargs,
  97                                       "|O!:attach", kwlist,
  98                                       &PyGMainContext_Type, &py_context))
  99         return NULL;
 100
 101     if (py_context)
 102         context = py_context->context;
 103
 104     CHECK_DESTROYED(self, NULL);
 105
 106     if (self->python_source) {
 107         PyGRealSource *pysource = (PyGRealSource *)self->source;
 108         Py_INCREF(pysource->obj);
 109     }
 110
 111     id = g_source_attach(self->source, context);
 112     return _PyLong_FromLong(id);
 113 }
 114
 115 static PyObject *
 116 pyg_source_destroy(PyGSource *self)
 117 {
 118     CHECK_DESTROYED(self, NULL);
 119
 120     if (self->python_source && self->source->context) {
 121         PyGRealSource *pysource = (PyGRealSource *)self->source;
 122         Py_DECREF(pysource->obj);
 123     }
 124
 125     g_source_destroy(self->source);
 126     self->source = NULL;
 127
 128     Py_INCREF(Py_None);
 129     return Py_None;
 130 }
 131
 132 static PyObject *
 133 pyg_source_set_callback(PyGSource *self, PyObject *args)
 134 {
 135     PyObject *first, *callback, *cbargs = NULL, *data;
 136     gint len;
 137
 138     CHECK_DESTROYED(self, NULL);
 139
 140     len = PyTuple_Size (args);
 141     if (len < 1) {
 142         PyErr_SetString(PyExc_TypeError,
 143                         "set_callback requires at least 1 argument");
 144         return NULL;
 145     }
 146
 147     first = PySequence_GetSlice(args, 0, 1);
 148     if (!PyArg_ParseTuple(first, "O:set_callback", &callback)) {
 149         Py_DECREF (first);
 150         return NULL;
 151     }
 152     Py_DECREF(first);
 153
 154     if (!PyCallable_Check(callback)) {
 155         PyErr_SetString(PyExc_TypeError, "first argument not callable");
 156         return NULL;
 157     }
 158
 159     cbargs = PySequence_GetSlice(args, 1, len);
 160     if (cbargs == NULL)
 161         return NULL;
 162
 163     data = Py_BuildValue("(ON)", callback, cbargs);
 164     if (data == NULL)
 165         return NULL;
 166
 167     g_source_set_callback(self->source,
 168                           _pyglib_handler_marshal, data,
 169                           _pyglib_destroy_notify);
 170
 171     Py_INCREF(Py_None);
 172     return Py_None;
 173 }
 174
 175 static PyObject *
 176 pyg_source_get_context(PyGSource *self)
 177 {
 178     GMainContext *context;
 179
 180     CHECK_DESTROYED(self, NULL);
 181
 182     context = g_source_get_context(self->source);
 183
 184     if (context) {
 185         return pyglib_main_context_new(context);
 186     } else {
 187         Py_INCREF(Py_None);
 188         return Py_None;
 189     }
 190 }
 191
 192 static PyObject *
 193 pyg_source_add_poll(PyGSource *self, PyObject *args, PyObject *kwargs)
 194 {
 195     static char *kwlist[] = { "fd", NULL };
 196     PyGPollFD *fd;
 197
 198     if (!self->python_source) {
 199         PyErr_SetString(PyExc_TypeError,
 200                         "add_poll can only be used with sources "
 201                         "implemented in python");
 202         return NULL;
 203     }
 204
 205     if (!PyArg_ParseTupleAndKeywords(args, kwargs,
 206                                      "O!:add_poll", kwlist,
 207                                      &PyGPollFD_Type, &fd))
 208         return NULL;
 209
 210     CHECK_DESTROYED(self, NULL);
 211
 212     g_source_add_poll(self->source, &fd->pollfd);
 213
 214     Py_INCREF(Py_None);
 215     return Py_None;
 216 }
 217
 218 static PyObject *
 219 pyg_source_remove_poll(PyGSource *self, PyObject *args, PyObject *kwargs)
 220 {
 221     static char *kwlist[] = { "fd", NULL };
 222     PyGPollFD *fd;
 223
 224     if (!self->python_source) {
 225         PyErr_SetString(PyExc_TypeError,
 226                         "remove_poll can only be used with sources "
 227                         "implemented in python");
 228         return NULL;
 229     }
 230
 231     if (!PyArg_ParseTupleAndKeywords(args, kwargs,
 232                                      "O!:remove_poll", kwlist,
 233                                      &PyGPollFD_Type, &fd))
 234         return NULL;
 235
 236     CHECK_DESTROYED(self, NULL);
 237
 238     g_source_remove_poll(self->source, &fd->pollfd);
 239
 240     Py_INCREF(Py_None);
 241     return Py_None;
 242 }
 243
 244 static PyObject *
 245 pyg_source_get_current_time(PyGSource *self)
 246 {
 247     GTimeVal timeval;
 248     double   ret;
 249
 250     CHECK_DESTROYED(self, NULL);
 251
 252     g_source_get_current_time(self->source, &timeval);
 253     ret = (double)timeval.tv_sec + (double)timeval.tv_usec * 0.000001;
 254     return PyFloat_FromDouble(ret);
 255 }
 256
 257 static PyMethodDef pyg_source_methods[] = {
 258     { "attach", (PyCFunction)pyg_source_attach, METH_KEYWORDS },
 259     { "destroy", (PyCFunction)pyg_source_destroy, METH_NOARGS },
 260     { "set_callback", (PyCFunction)pyg_source_set_callback, METH_VARARGS },
 261     { "get_context", (PyCFunction)pyg_source_get_context, METH_NOARGS },
 262     { "add_poll", (PyCFunction)pyg_source_add_poll, METH_KEYWORDS },
 263     { "remove_poll", (PyCFunction)pyg_source_remove_poll, METH_KEYWORDS },
 264     { "get_current_time", (PyCFunction)pyg_source_get_current_time, METH_NOARGS },
 265     { NULL, NULL, 0 }
 266 };
 267
 268 static PyObject *
 269 pyg_source_get_dict(PyGSource *self, void *closure)
 270 {
 271     if (self->inst_dict == NULL) {
 272         self->inst_dict = PyDict_New();
 273         if (self->inst_dict == NULL)
 274             return NULL;
 275     }
 276
 277     Py_INCREF(self->inst_dict);
 278     return self->inst_dict;
 279 }
 280
 281 static PyObject *
 282 pyg_source_get_priority(PyGSource *self, void *closure)
 283 {
 284     CHECK_DESTROYED(self, NULL);
 285
 286     return _PyLong_FromLong(g_source_get_priority(self->source));
 287 }
 288
 289 static int
 290 pyg_source_set_priority(PyGSource *self, PyObject *value, void *closure)
 291 {
 292     CHECK_DESTROYED(self, -1);
 293
 294     if (value == NULL) {
 295         PyErr_SetString(PyExc_TypeError, "cannot delete priority");
 296         return -1;
 297     }
 298
 299     if (!_PyLong_Check(value)) {
 300         PyErr_SetString(PyExc_TypeError, "type mismatch");
 301         return -1;
 302     }
 303
 304     g_source_set_priority(self->source, _PyLong_AsLong(value));
 305
 306     return 0;
 307 }
 308
 309 static PyObject *
 310 pyg_source_get_can_recurse(PyGSource *self, void *closure)
 311 {
 312     CHECK_DESTROYED(self, NULL);
 313
 314     return PyBool_FromLong(g_source_get_can_recurse(self->source));
 315 }
 316
 317 static int
 318 pyg_source_set_can_recurse(PyGSource *self, PyObject *value, void *closure)
 319 {
 320     CHECK_DESTROYED(self, -1);
 321
 322     if (value == NULL) {
 323         PyErr_SetString(PyExc_TypeError, "cannot delete can_recurse");
 324         return -1;
 325     }
 326
 327     g_source_set_can_recurse(self->source, PyObject_IsTrue(value));
 328
 329     return 0;
 330 }
 331
 332 static PyObject *
 333 pyg_source_get_id(PyGSource *self, void *closure)
 334 {
 335     CHECK_DESTROYED(self, NULL);
 336
 337     if (g_source_get_context(self->source) == NULL) {
 338         PyErr_SetString(PyExc_RuntimeError, "source is not attached");
 339         return NULL;
 340     }
 341
 342     return _PyLong_FromLong(g_source_get_id(self->source));
 343 }
 344
 345 static PyGetSetDef pyg_source_getsets[] = {
 346     { "__dict__", (getter)pyg_source_get_dict,  (setter)0 },
 347     {"priority", (getter)pyg_source_get_priority, (setter)pyg_source_set_priority },
 348     {"can_recurse", (getter)pyg_source_get_can_recurse, (setter)pyg_source_set_can_recurse },
 349     {"id", (getter)pyg_source_get_id, (setter)0 },
 350     {NULL, 0, 0}
 351 };
 352
 353 static PyObject *
 354 pyg_source_repr(PyGSource *self)
 355 {
 356     return source_repr(self, NULL);
 357 }
 358
 359 static int
 360 pyg_source_traverse(PyGSource *self, visitproc visit, void *arg)
 361 {
 362     int ret = 0;
 363
 364     if (self->inst_dict) ret = visit(self->inst_dict, arg);
 365     if (ret != 0) return ret;
 366
 367     return 0;
 368 }
 369
 370 static int
 371 pyg_source_clear(PyGSource *self)
 372 {
 373     PyObject *tmp;
 374
 375     tmp = self->inst_dict;
 376     self->inst_dict = NULL;
 377     Py_XDECREF(tmp);
 378
 379     if (self->source) {
 380         g_source_unref(self->source);
 381         self->source = NULL;
 382     }
 383
 384     return 0;
 385 }
 386
 387 static void
 388 pyg_source_dealloc(PyGSource *self)
 389 {
 390     PyObject_ClearWeakRefs((PyObject *)self);
 391
 392     PyObject_GC_UnTrack((PyObject *)self);
 393
 394     pyg_source_clear(self);
 395
 396     PyObject_GC_Del(self);
 397 }
 398
 399 static gboolean
 400 pyg_source_prepare(GSource *source, gint *timeout)
 401 {
 402     PyGRealSource *pysource = (PyGRealSource *)source;
 403     PyObject *t;
 404     gboolean ret = FALSE;
 405     gboolean got_err = TRUE;
 406     PyGILState_STATE state;
 407
 408     state = pyglib_gil_state_ensure();
 409
 410     t = PyObject_CallMethod(pysource->obj, "prepare", NULL);
 411
 412     if (t == NULL) {
 413         goto bail;
 414     } else if (!PyObject_IsTrue(t)) {
 415         got_err = FALSE;
 416         goto bail;
 417     } else if (!PyTuple_Check(t)) {
 418         PyErr_SetString(PyExc_TypeError,
 419                         "source prepare function must return a tuple or False");
 420         goto bail;
 421     } else if (PyTuple_Size(t) != 2) {
 422         PyErr_SetString(PyExc_TypeError,
 423                         "source prepare function return tuple must be exactly "
 424                         "2 elements long");
 425         goto bail;
 426     }
 427
 428     ret = PyObject_IsTrue(PyTuple_GET_ITEM(t, 0));
 429         *timeout = _PyLong_AsLong(PyTuple_GET_ITEM(t, 1));
 430
 431         if (*timeout == -1 && PyErr_Occurred()) {
 432             ret = FALSE;
 433             goto bail;
 434         }
 435
 436     got_err = FALSE;
 437
 438 bail:
 439     if (got_err)
 440         PyErr_Print();
 441
 442     Py_XDECREF(t);
 443
 444     pyglib_gil_state_release(state);
 445
 446     return ret;
 447 }
 448
 449 static gboolean
 450 pyg_source_check(GSource *source)
 451 {
 452     PyGRealSource *pysource = (PyGRealSource *)source;
 453     PyObject *t;
 454     gboolean ret;
 455     PyGILState_STATE state;
 456
 457     state = pyglib_gil_state_ensure();
 458
 459     t = PyObject_CallMethod(pysource->obj, "check", NULL);
 460
 461     if (t == NULL) {
 462         PyErr_Print();
 463         ret = FALSE;
 464     } else {
 465         ret = PyObject_IsTrue(t);
 466         Py_DECREF(t);
 467     }
 468
 469     pyglib_gil_state_release(state);
 470
 471     return ret;
 472 }
 473
 474 static gboolean
 475 pyg_source_dispatch(GSource *source, GSourceFunc callback, gpointer user_data)
 476 {
 477     PyGRealSource *pysource = (PyGRealSource *)source;
 478     PyObject *func, *args, *tuple, *t;
 479     gboolean ret;
 480     PyGILState_STATE state;
 481
 482     state = pyglib_gil_state_ensure();
 483
 484     if (callback) {
 485         tuple = user_data;
 486
 487         func = PyTuple_GetItem(tuple, 0);
 488         args = PyTuple_GetItem(tuple, 1);
 489     } else {
 490         func = Py_None;
 491         args = Py_None;
 492     }
 493
 494     t = PyObject_CallMethod(pysource->obj, "dispatch", "OO", func, args);
 495
 496     if (t == NULL) {
 497         PyErr_Print();
 498         ret = FALSE;
 499     } else {
 500         ret = PyObject_IsTrue(t);
 501         Py_DECREF(t);
 502     }
 503
 504     pyglib_gil_state_release(state);
 505
 506     return ret;
 507 }
 508
 509 static void
 510 pyg_source_finalize(GSource *source)
 511 {
 512     PyGRealSource *pysource = (PyGRealSource *)source;
 513     PyObject *func, *t;
 514     PyGILState_STATE state;
 515
 516     state = pyglib_gil_state_ensure();
 517
 518     func = PyObject_GetAttrString(pysource->obj, "finalize");
 519     if (func) {
 520         t = PyObject_CallObject(func, NULL);
 521         Py_DECREF(func);
 522
 523         if (t == NULL) {
 524             PyErr_Print();
 525         } else {
 526             Py_DECREF(t);
 527         }
 528     }
 529
 530     pyglib_gil_state_release(state);
 531 }
 532
 533 static GSourceFuncs pyg_source_funcs =
 534 {
 535     pyg_source_prepare,
 536     pyg_source_check,
 537     pyg_source_dispatch,
 538     pyg_source_finalize
 539 };
 540
 541 static int
 542 pyg_source_init(PyGSource *self, PyObject *args, PyObject *kwargs)
 543 {
 544     PyGRealSource *pysource;
 545
 546     self->source = g_source_new(&pyg_source_funcs, sizeof(PyGRealSource));
 547
 548     pysource = (PyGRealSource *)self->source;
 549     pysource->obj = (PyObject*)self;
 550
 551     self->inst_dict = NULL;
 552     self->weakreflist = NULL;
 553
 554     self->python_source = TRUE;
 555
 556     return 0;
 557 }
 558
 559 static void
 560 pyg_source_free(PyObject *op)
 561 {
 562     PyObject_GC_Del(op);
 563 }
 564
 565 /* glib.Idle */
 566
 567 PYGLIB_DEFINE_TYPE("glib.Idle", PyGIdle_Type, PyGSource)
 568
 569 static PyObject *
 570 pyg_idle_repr(PyGSource *self)
 571 {
 572     return source_repr(self, "idle");
 573 }
 574
 575 static int
 576 pyg_idle_init(PyGSource *self, PyObject *args, PyObject *kwargs)
 577 {
 578     static char *kwlist[] = { "priority", NULL };
 579     gint priority = G_PRIORITY_DEFAULT_IDLE;
 580
 581     if (!PyArg_ParseTupleAndKeywords(args, kwargs,
 582                                      "|i:glib.Idle.__init__", kwlist,
 583                                      &priority))
 584         return -1;
 585
 586     self->source = g_idle_source_new ();
 587
 588     if (priority != G_PRIORITY_DEFAULT_IDLE)
 589         g_source_set_priority(self->source, priority);
 590
 591     self->inst_dict = NULL;
 592     self->weakreflist = NULL;
 593
 594     self->python_source = FALSE;
 595
 596     return 0;
 597 }
 598
 599 /* glib.Timeout */
 600
 601 PYGLIB_DEFINE_TYPE("glib.Timeout", PyGTimeout_Type, PyGSource)
 602
 603 static PyObject *
 604 pyg_timeout_repr(PyGSource *self)
 605 {
 606     return source_repr(self, "timeout");
 607 }
 608
 609 static int
 610 pyg_timeout_init(PyGSource *self, PyObject *args, PyObject *kwargs)
 611 {
 612     static char *kwlist[] = { "interval", "priority", NULL };
 613     gint priority = G_PRIORITY_DEFAULT;
 614     guint interval;
 615
 616     if (!PyArg_ParseTupleAndKeywords(args, kwargs,
 617                                      "I|i:glib.Timeout.__init__", kwlist,
 618                                      &interval, &priority))
 619         return -1;
 620
 621     self->source = g_timeout_source_new(interval);
 622
 623     if (priority != G_PRIORITY_DEFAULT)
 624         g_source_set_priority(self->source, priority);
 625
 626     self->inst_dict = NULL;
 627     self->weakreflist = NULL;
 628
 629     self->python_source = FALSE;
 630
 631     return 0;
 632 }
 633
 634 /* glib.PollFD */
 635
 636 PYGLIB_DEFINE_TYPE("glib.PollFD", PyGPollFD_Type, PyGPollFD)
 637
 638 static PyMemberDef pyg_poll_fd_members[] = {
 639     { "fd",      T_INT,    offsetof(PyGPollFD, pollfd.fd),      READONLY },
 640     { "events",  T_USHORT, offsetof(PyGPollFD, pollfd.events),  READONLY },
 641     { "revents", T_USHORT, offsetof(PyGPollFD, pollfd.revents), READONLY },
 642     { NULL, 0, 0, 0 }
 643 };
 644
 645 static void
 646 pyg_poll_fd_dealloc(PyGPollFD *self)
 647 {
 648     Py_XDECREF(self->fd_obj);
 649     PyObject_DEL(self);
 650 }
 651
 652 static PyObject *
 653 pyg_poll_fd_repr(PyGPollFD *self)
 654 {
 655     return _PyUnicode_FromFormat("<GPollFD %d (%d) at 0x%lx>",
 656                                  self->pollfd.fd, self->pollfd.events,
 657                                  (long)self);
 658 }
 659
 660 static int
 661 pyg_poll_fd_init(PyGPollFD *self, PyObject *args, PyObject *kwargs)
 662 {
 663     static char *kwlist[] = { "fd", "events", NULL };
 664     PyObject *o;
 665     gint fd;
 666     gushort events;
 667
 668     if (!PyArg_ParseTupleAndKeywords(args, kwargs,
 669                                      "OH:glib.PollFD.__init__", kwlist,
 670                                      &o, &events))
 671         return -1;
 672
 673     fd = PyObject_AsFileDescriptor(o);
 674     if (fd == -1)
 675         return -1;
 676
 677     self->pollfd.fd = fd;
 678     self->pollfd.events = events;
 679     self->pollfd.revents = 0;
 680
 681     Py_INCREF(o);
 682     self->fd_obj = o;
 683
 684     return 0;
 685 }
 686
 687 void
 688 pyglib_source_register_types(PyObject *d)
 689 {
 690     PyGSource_Type.tp_flags = (Py_TPFLAGS_DEFAULT |
 691                                Py_TPFLAGS_BASETYPE |
 692                                Py_TPFLAGS_HAVE_GC);
 693     PyGSource_Type.tp_init = (initproc)pyg_source_init;
 694     PyGSource_Type.tp_free = (freefunc)pyg_source_free;
 695     PyGSource_Type.tp_dealloc = (destructor)pyg_source_dealloc;
 696     PyGSource_Type.tp_methods = pyg_source_methods;
 697     PyGSource_Type.tp_repr = (reprfunc)pyg_source_repr;
 698     PyGSource_Type.tp_traverse = (traverseproc)pyg_source_traverse;
 699     PyGSource_Type.tp_clear = (inquiry)pyg_source_clear;
 700     PyGSource_Type.tp_getset = pyg_source_getsets;
 701     PyGSource_Type.tp_weaklistoffset = offsetof(PyGSource, weakreflist);
 702     PyGSource_Type.tp_dictoffset = offsetof(PyGSource, inst_dict);
 703     PYGLIB_REGISTER_TYPE(d, PyGSource_Type, "Source");
 704
 705     PyGIdle_Type.tp_repr = (reprfunc)pyg_idle_repr;
 706     PyGIdle_Type.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE;
 707     PyGIdle_Type.tp_base = (PyTypeObject *)&PyGSource_Type;
 708     PyGIdle_Type.tp_init = (initproc)pyg_idle_init;
 709     PYGLIB_REGISTER_TYPE(d, PyGIdle_Type, "Idle");
 710
 711     PyGTimeout_Type.tp_repr = (reprfunc)pyg_timeout_repr;
 712     PyGTimeout_Type.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE;
 713     PyGTimeout_Type.tp_base = (PyTypeObject *)&PyGSource_Type;
 714     PyGTimeout_Type.tp_init = (initproc)pyg_timeout_init;
 715     PYGLIB_REGISTER_TYPE(d, PyGTimeout_Type, "Timeout");
 716
 717     PyGPollFD_Type.tp_dealloc = (destructor)pyg_poll_fd_dealloc;
 718     PyGPollFD_Type.tp_repr = (reprfunc)pyg_poll_fd_repr;
 719     PyGPollFD_Type.tp_flags = Py_TPFLAGS_DEFAULT;
 720     PyGPollFD_Type.tp_members = pyg_poll_fd_members;
 721     PyGPollFD_Type.tp_init = (initproc)pyg_poll_fd_init;
 722     PYGLIB_REGISTER_TYPE(d, PyGPollFD_Type, "PollFD");
 723 }