PyObject *
init_util(void)
{
PyObject *module;
#ifdef PYUV_PYTHON3
module = PyModule_Create(&pyuv_util_module);
#else
module = Py_InitModule("pyuv.util", Util_methods);
#endif
if (module == NULL) {
return NULL;
}
/* initialize PyStructSequence types */
if (CPUInfoResultType.tp_name == 0)
PyStructSequence_InitType(&CPUInfoResultType, &cpu_info_result_desc);
if (CPUInfoTimesResultType.tp_name == 0)
PyStructSequence_InitType(&CPUInfoTimesResultType, &cpu_info_times_result_desc);
if (InterfaceAddressesResultType.tp_name == 0)
PyStructSequence_InitType(&InterfaceAddressesResultType, &interface_addresses_result_desc);
if (RusageResultType.tp_name == 0)
PyStructSequence_InitType(&RusageResultType, &rusage_result_desc);
SignalCheckerType.tp_base = &HandleType;
PyUVModule_AddType(module, "SignalChecker", &SignalCheckerType);
return module;
}
PyObject *
init_dns(void)
{
PyObject *module;
#ifdef PYUV_PYTHON3
module = PyModule_Create(&pyuv_dns_module);
#else
module = Py_InitModule("pyuv.dns", NULL);
#endif
if (module == NULL) {
return NULL;
}
PyModule_AddIntMacro(module, ARES_NI_NOFQDN);
PyModule_AddIntMacro(module, ARES_NI_NUMERICHOST);
PyModule_AddIntMacro(module, ARES_NI_NAMEREQD);
PyModule_AddIntMacro(module, ARES_NI_NUMERICSERV);
PyModule_AddIntMacro(module, ARES_NI_DGRAM);
PyModule_AddIntMacro(module, ARES_NI_TCP);
PyModule_AddIntMacro(module, ARES_NI_UDP);
PyModule_AddIntMacro(module, ARES_NI_SCTP);
PyModule_AddIntMacro(module, ARES_NI_DCCP);
PyModule_AddIntMacro(module, ARES_NI_NUMERICSCOPE);
PyModule_AddIntMacro(module, ARES_NI_LOOKUPHOST);
PyModule_AddIntMacro(module, ARES_NI_LOOKUPSERVICE);
PyModule_AddIntMacro(module, ARES_NI_IDN);
PyModule_AddIntMacro(module, ARES_NI_IDN_ALLOW_UNASSIGNED);
PyModule_AddIntMacro(module, ARES_NI_IDN_USE_STD3_ASCII_RULES);
PyUVModule_AddType(module, "DNSResolver", &DNSResolverType);
return module;
}
PyObject *
init_thread(void)
{
PyObject *module;
#ifdef PYUV_PYTHON3
module = PyModule_Create(&pyuv_thread_module);
#else
module = Py_InitModule("pyuv.thread", NULL);
#endif
if (module == NULL) {
return NULL;
}
PyUVModule_AddType(module, "Barrier", &BarrierType);
PyUVModule_AddType(module, "Condition", &ConditionType);
PyUVModule_AddType(module, "Mutex", &MutexType);
PyUVModule_AddType(module, "RWLock", &RWLockType);
PyUVModule_AddType(module, "Semaphore", &SemaphoreType);
return module;
}
/* Module */
PyObject*
init_pyuv(void)
{
/* Modules */
PyObject *pyuv;
PyObject *errno_module;
PyObject *error_module;
PyObject *fs_module;
PyObject *util_module;
/* Initialize GIL */
PyEval_InitThreads();
#ifdef PYUV_WINDOWS
if (pyuv_setmaxstdio()) {
return NULL;
}
#endif
/* Main module */
#ifdef PYUV_PYTHON3
pyuv = PyModule_Create(&pyuv_module);
#else
pyuv = Py_InitModule("pyuv", NULL);
#endif
/* Errno module */
errno_module = init_errno();
if (errno_module == NULL) {
goto fail;
}
PyUVModule_AddObject(pyuv, "errno", errno_module);
#ifdef PYUV_PYTHON3
PyDict_SetItemString(PyImport_GetModuleDict(), pyuv_errno_module.m_name, errno_module);
Py_DECREF(errno_module);
#endif
/* Error module */
error_module = init_error();
if (error_module == NULL) {
goto fail;
}
PyUVModule_AddObject(pyuv, "error", error_module);
#ifdef PYUV_PYTHON3
PyDict_SetItemString(PyImport_GetModuleDict(), pyuv_error_module.m_name, error_module);
Py_DECREF(error_module);
#endif
/* FS module */
fs_module = init_fs();
if (fs_module == NULL) {
goto fail;
}
PyUVModule_AddObject(pyuv, "fs", fs_module);
#ifdef PYUV_PYTHON3
PyDict_SetItemString(PyImport_GetModuleDict(), pyuv_fs_module.m_name, fs_module);
Py_DECREF(fs_module);
#endif
/* Util module */
util_module = init_util();
if (util_module == NULL) {
goto fail;
}
PyUVModule_AddObject(pyuv, "util", util_module);
#ifdef PYUV_PYTHON3
PyDict_SetItemString(PyImport_GetModuleDict(), pyuv_util_module.m_name, util_module);
Py_DECREF(util_module);
#endif
/* Types */
AsyncType.tp_base = &HandleType;
TimerType.tp_base = &HandleType;
PrepareType.tp_base = &HandleType;
IdleType.tp_base = &HandleType;
CheckType.tp_base = &HandleType;
SignalType.tp_base = &HandleType;
UDPType.tp_base = &HandleType;
PollType.tp_base = &HandleType;
ProcessType.tp_base = &HandleType;
StreamType.tp_base = &HandleType;
TCPType.tp_base = &StreamType;
PipeType.tp_base = &StreamType;
TTYType.tp_base = &StreamType;
PyUVModule_AddType(pyuv, "Loop", &LoopType);
PyUVModule_AddType(pyuv, "Async", &AsyncType);
PyUVModule_AddType(pyuv, "Timer", &TimerType);
PyUVModule_AddType(pyuv, "Prepare", &PrepareType);
PyUVModule_AddType(pyuv, "Idle", &IdleType);
PyUVModule_AddType(pyuv, "Check", &CheckType);
PyUVModule_AddType(pyuv, "Signal", &SignalType);
PyUVModule_AddType(pyuv, "TCP", &TCPType);
PyUVModule_AddType(pyuv, "Pipe", &PipeType);
PyUVModule_AddType(pyuv, "TTY", &TTYType);
PyUVModule_AddType(pyuv, "UDP", &UDPType);
PyUVModule_AddType(pyuv, "Poll", &PollType);
PyUVModule_AddType(pyuv, "StdIO", &StdIOType);
PyUVModule_AddType(pyuv, "Process", &ProcessType);
PyUVModule_AddType(pyuv, "ThreadPool", &ThreadPoolType);
PyUVModule_AddType(pyuv, "SignalChecker", &SignalCheckerType);
/* UDP constants */
PyModule_AddIntMacro(pyuv, UV_JOIN_GROUP);
PyModule_AddIntMacro(pyuv, UV_LEAVE_GROUP);
/* Process constants */
PyModule_AddIntMacro(pyuv, UV_PROCESS_SETUID);
PyModule_AddIntMacro(pyuv, UV_PROCESS_SETGID);
PyModule_AddIntMacro(pyuv, UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS);
PyModule_AddIntMacro(pyuv, UV_PROCESS_DETACHED);
PyModule_AddIntMacro(pyuv, UV_IGNORE);
PyModule_AddIntMacro(pyuv, UV_CREATE_PIPE);
PyModule_AddIntMacro(pyuv, UV_READABLE_PIPE);
PyModule_AddIntMacro(pyuv, UV_WRITABLE_PIPE);
PyModule_AddIntMacro(pyuv, UV_INHERIT_FD);
PyModule_AddIntMacro(pyuv, UV_INHERIT_STREAM);
/* Poll constants */
PyModule_AddIntMacro(pyuv, UV_READABLE);
PyModule_AddIntMacro(pyuv, UV_WRITABLE);
/* Handle types */
PyModule_AddIntMacro(pyuv, UV_UNKNOWN_HANDLE);
#define XX(uc, lc) PyModule_AddIntMacro(pyuv, UV_##uc);
UV_HANDLE_TYPE_MAP(XX)
#undef XX
/* Module version (the MODULE_VERSION macro is defined by setup.py) */
PyModule_AddStringConstant(pyuv, "__version__", __MSTR(MODULE_VERSION));
/* libuv version */
PyModule_AddStringConstant(pyuv, "LIBUV_VERSION", __MSTR(LIBUV_VERSION));
return pyuv;
fail:
#ifdef PYUV_PYTHON3
Py_DECREF(pyuv);
#endif
return NULL;
}
PyObject *
init_error(void)
{
PyObject *module;
#ifdef PYUV_PYTHON3
module = PyModule_Create(&pyuv_error_module);
#else
module = Py_InitModule("pyuv.error", NULL);
#endif
if (module == NULL) {
return NULL;
}
PyExc_UVError = PyErr_NewException("pyuv.error.UVError", NULL, NULL);
PyExc_HandleError = PyErr_NewException("pyuv.error.HandleError", PyExc_UVError, NULL);
PyExc_HandleClosedError = PyErr_NewException("pyuv.error.HandleClosedError", PyExc_HandleError, NULL);
PyExc_AsyncError = PyErr_NewException("pyuv.error.AsyncError", PyExc_HandleError, NULL);
PyExc_TimerError = PyErr_NewException("pyuv.error.TimerError", PyExc_HandleError, NULL);
PyExc_PrepareError = PyErr_NewException("pyuv.error.PrepareError", PyExc_HandleError, NULL);
PyExc_IdleError = PyErr_NewException("pyuv.error.IdleError", PyExc_HandleError, NULL);
PyExc_CheckError = PyErr_NewException("pyuv.error.CheckError", PyExc_HandleError, NULL);
PyExc_SignalError = PyErr_NewException("pyuv.error.SignalError", PyExc_HandleError, NULL);
PyExc_StreamError = PyErr_NewException("pyuv.error.StreamError", PyExc_HandleError, NULL);
PyExc_TCPError = PyErr_NewException("pyuv.error.TCPError", PyExc_StreamError, NULL);
PyExc_PipeError = PyErr_NewException("pyuv.error.PipeError", PyExc_StreamError, NULL);
PyExc_TTYError = PyErr_NewException("pyuv.error.TTYError", PyExc_StreamError, NULL);
PyExc_UDPError = PyErr_NewException("pyuv.error.UDPError", PyExc_HandleError, NULL);
PyExc_PollError = PyErr_NewException("pyuv.error.PollError", PyExc_HandleError, NULL);
PyExc_DNSError = PyErr_NewException("pyuv.error.DNSError", NULL, NULL);
PyExc_ThreadPoolError = PyErr_NewException("pyuv.error.ThreadPoolError", PyExc_UVError, NULL);
PyExc_FSError = PyErr_NewException("pyuv.error.FSError", PyExc_UVError, NULL);
PyExc_FSEventError = PyErr_NewException("pyuv.error.FSEventError", PyExc_HandleError, NULL);
PyExc_FSPollError = PyErr_NewException("pyuv.error.FSPollError", PyExc_HandleError, NULL);
PyExc_ProcessError = PyErr_NewException("pyuv.error.ProcessError", PyExc_HandleError, NULL);
PyUVModule_AddType(module, "UVError", (PyTypeObject *)PyExc_UVError);
PyUVModule_AddType(module, "HandleError", (PyTypeObject *)PyExc_HandleError);
PyUVModule_AddType(module, "AsyncError", (PyTypeObject *)PyExc_AsyncError);
PyUVModule_AddType(module, "TimerError", (PyTypeObject *)PyExc_TimerError);
PyUVModule_AddType(module, "PrepareError", (PyTypeObject *)PyExc_PrepareError);
PyUVModule_AddType(module, "IdleError", (PyTypeObject *)PyExc_IdleError);
PyUVModule_AddType(module, "CheckError", (PyTypeObject *)PyExc_CheckError);
PyUVModule_AddType(module, "SignalError", (PyTypeObject *)PyExc_SignalError);
PyUVModule_AddType(module, "StreamError", (PyTypeObject *)PyExc_StreamError);
PyUVModule_AddType(module, "TCPError", (PyTypeObject *)PyExc_TCPError);
PyUVModule_AddType(module, "PipeError", (PyTypeObject *)PyExc_PipeError);
PyUVModule_AddType(module, "TTYError", (PyTypeObject *)PyExc_TTYError);
PyUVModule_AddType(module, "UDPError", (PyTypeObject *)PyExc_UDPError);
PyUVModule_AddType(module, "PollError", (PyTypeObject *)PyExc_PollError);
PyUVModule_AddType(module, "DNSError", (PyTypeObject *)PyExc_DNSError);
PyUVModule_AddType(module, "ThreadPoolError", (PyTypeObject *)PyExc_ThreadPoolError);
PyUVModule_AddType(module, "FSError", (PyTypeObject *)PyExc_FSError);
PyUVModule_AddType(module, "FSEventError", (PyTypeObject *)PyExc_FSEventError);
PyUVModule_AddType(module, "FSPollError", (PyTypeObject *)PyExc_FSPollError);
PyUVModule_AddType(module, "ProcessError", (PyTypeObject *)PyExc_ProcessError);
return module;
}
