PyMODINIT_FUNC inittradesocket(void) { Py_InitModule3("tradesocket", tradesocket_methods, tradesocket__doc__); }
PyMODINIT_FUNC initwave2d_cfunc() { Py_InitModule3("wave2d_cfunc", wave2d_cfunc_methods, module_doc); import_array(); }
//initialise the module PyMODINIT_FUNC initRadialVelocity(void) { (void) Py_InitModule3("RadialVelocity", RadialVelocityMethods, "Radial vel docstring..."); import_array(); //must be present for numpy stuff }
PyMODINIT_FUNC initguiQt(void) { PyEval_InitThreads(); /* Start the interpreter's thread-awareness */ if(PyType_Ready(&QtGuiObject_Type) < 0) { Py_FatalError("Can't initialize QtGuiObject type"); return; } PyObject* m = Py_InitModule3("guiQt", module_methods, module_doc); if(!m) { Py_FatalError("Can't initialize guiQt module"); return; } bool fail = false; if(PyModule_AddObject(m, "QtGuiObject", (PyObject*) &QtGuiObject_Type) != 0) fail = true; iterControlTypes([&](const std::string& controlType, ControlBuilderFunc builderFunc) { struct PythonWrapper { std::string controlType; ControlBuilderFunc builderFunc; PyObject* operator()(PyObject* args, PyObject* kw) { PyObject* control = NULL; if(!PyArg_ParseTuple(args, ("O:buildControl" + controlType).c_str(), &control)) return NULL; if(!PyType_IsSubtype(Py_TYPE(control), &QtGuiObject_Type)) { PyErr_Format(PyExc_ValueError, "guiQt.buildControl%s: we expect a QtGuiObject", controlType.c_str()); return NULL; } PyQtGuiObject* guiObject = (PyQtGuiObject*) control; bool res = builderFunc(guiObject); if(!res) // XXX: handle somehow? ... printf("guiQt.buildControl%s: warning, returned error\n", controlType.c_str()); Py_INCREF(control); return control; } }; PythonWrapper wrapper; wrapper.controlType = controlType; wrapper.builderFunc = builderFunc; PyObject* funcObj = (PyObject*) newFunctionWrapper(wrapper); if(!funcObj) { fail = true; return; } if(PyModule_AddObject(m, ("builControl" + controlType).c_str(), funcObj) != 0) fail = true; }); if(fail) { if(PyErr_Occurred()) PyErr_Print(); Py_FatalError("guiQt module init error"); } }
PyMODINIT_FUNC init_svgview() { Py_InitModule3("_svgview", _viewer_methods, ""); rsvg_init(); g_thread_init(NULL); gdk_threads_init(); }
PyMODINIT_FUNC init_phono4py(void) { Py_InitModule3("_phono4py", functions, "C-extension for phono4py\n\n...\n"); return; }
PyMODINIT_FUNC initEfiCompressor(VOID) { Py_InitModule3("EfiCompressor", EfiCompressor_Funcs, "EFI Compression Algorithm Extension Module"); }
/* Init module function */ void initangie_c(void) { //printf("ANGIE [optimized, c] module was initialized!\n"); Py_InitModule3("angie_c", angie_c_funcs, "ANGIE"); }
PyMODINIT_FUNC init_laplacian(void) { Py_InitModule3("_laplacian", _functions, "Second degree Laplacian edge detection accelerator module."); }
PyMODINIT_FUNC init_ExtensionClass(void) { PyObject *m, *s; if (pickle_setup() < 0) return; #define DEFINE_STRING(S) \ if(! (str ## S = PyString_FromString(# S))) return DEFINE_STRING(__of__); DEFINE_STRING(__get__); DEFINE_STRING(__class_init__); DEFINE_STRING(__init__); DEFINE_STRING(__bases__); DEFINE_STRING(__mro__); DEFINE_STRING(__new__); #undef DEFINE_STRING PyExtensionClassCAPI = &TrueExtensionClassCAPI; ExtensionClassType.ob_type = &PyType_Type; ExtensionClassType.tp_base = &PyType_Type; ExtensionClassType.tp_basicsize = PyType_Type.tp_basicsize; ExtensionClassType.tp_traverse = PyType_Type.tp_traverse; ExtensionClassType.tp_clear = PyType_Type.tp_clear; /* Initialize types: */ if (PyType_Ready(&ExtensionClassType) < 0) return; BaseType.ob_type = &ExtensionClassType; BaseType.tp_base = &PyBaseObject_Type; BaseType.tp_basicsize = PyBaseObject_Type.tp_basicsize; BaseType.tp_new = PyType_GenericNew; if (PyType_Ready(&BaseType) < 0) return; NoInstanceDictionaryBaseType.ob_type = &ExtensionClassType; NoInstanceDictionaryBaseType.tp_base = &BaseType; NoInstanceDictionaryBaseType.tp_basicsize = BaseType.tp_basicsize; NoInstanceDictionaryBaseType.tp_new = PyType_GenericNew; if (PyType_Ready(&NoInstanceDictionaryBaseType) < 0) return; /* Create the module and add the functions */ m = Py_InitModule3("_ExtensionClass", ec_methods, _extensionclass_module_documentation); if (m == NULL) return; s = PyCObject_FromVoidPtr(PyExtensionClassCAPI, NULL); if (PyModule_AddObject(m, "CAPI2", s) < 0) return; /* Add types: */ if (PyModule_AddObject(m, "ExtensionClass", (PyObject *)&ExtensionClassType) < 0) return; if (PyModule_AddObject(m, "Base", (PyObject *)&BaseType) < 0) return; if (PyModule_AddObject(m, "NoInstanceDictionaryBase", (PyObject *)&NoInstanceDictionaryBaseType) < 0) return; }
void initedit_distance(void) { PyObject *m = Py_InitModule3(module_name, module_methods, module_docstring); if (m == NULL) return; }
int main(int argc, char *argv[]) { std::cout << "C++: This is process: " << getpid() << std::endl; PyObject *pName, *pModule, *pFunc; //, *pDict, ; PyObject *pValue; // *pArgs, // int i; std::string module("python6"); std::string function("run_now"); // Initilize Python Py_Initialize(); /* NameObjectType.tp_new = PyType_GenericNew; if (PyType_Ready(&NameObjectType) < 0) { PyErr_Print(); fprintf(stderr, "Type not ready - PyType_Ready\n"); return 1; } */ PyTypeObject* type_object = create_type_object(); if (PyType_Ready(type_object) < 0) { PyErr_Print(); fprintf(stderr, "Type not ready - PyType_Ready\n"); free_type_object(type_object); return 1; } PyObject* m = Py_InitModule3("name", NULL, "XXX"); if (!m) { PyErr_Print(); fprintf(stderr, "Failed to load initilize module - Py_InitModule3\n"); free_type_object(type_object); return 1; } /*Py_INCREF(&NameObjectType); PyModule_AddObject(m, "Name", (PyObject *)&NameObjectType);*/ Py_INCREF(type_object); PyModule_AddObject(m, "Name", (PyObject*)type_object); // Load module python2.py pName = PyString_FromString(module.c_str()); // Error checking of pName left out pModule = PyImport_Import(pName); Py_DECREF(pName); if (!pModule) { PyErr_Print(); fprintf(stderr, "Failed to load \"%s\"\n", argv[1]); free_type_object(type_object); return 1; } // Get the python fuction to call pFunc = PyObject_GetAttrString(pModule, function.c_str()); // pFunc is a new reference if (!pFunc || !PyCallable_Check(pFunc)) { if (PyErr_Occurred()) PyErr_Print(); fprintf(stderr, "Cannot find function \"%s\"\n", argv[2]); Py_XDECREF(pFunc); Py_DECREF(pModule); free_type_object(type_object); return 1; } // Make the call to the python function pValue = PyObject_CallObject(pFunc, NULL); if (!pValue) { PyErr_Print(); fprintf(stderr,"Call failed\n"); Py_DECREF(pFunc); Py_DECREF(pModule); free_type_object(type_object); return 1; } // Show the result of the python call printf("Result of call: %ld\n", PyInt_AsLong(pValue)); // Decrease counters for python garbage collection Py_DECREF(pValue); Py_XDECREF(pFunc); Py_DECREF(pModule); std::cout << "Before Py_Finalize()" << std::endl; // Clean up python Py_Finalize(); free_type_object(type_object); std::cout << "Freeing the allocated memory" << std::endl; return 0; }
PyMODINIT_FUNC initmpatch(void) { Py_InitModule3("mpatch", methods, mpatch_doc); mpatch_Error = PyErr_NewException("mpatch.mpatchError", NULL, NULL); }
PyMODINIT_FUNC init_spglib(void) { Py_InitModule3("_spglib", functions, "C-extension for spglib\n\n...\n"); return; }
PyMODINIT_FUNC initdefault_encoding_utf8(void) { PyUnicode_SetDefaultEncoding("utf-8"); Py_InitModule3("default_encoding_utf8", methods, "Forces the default encoding to utf-8"); }
void init_perlin(void) { Py_InitModule3("_perlin", perlin_functions, module_doc); }
PyMODINIT_FUNC initred(void) { Py_InitModule3("red", methods, NULL); }
PyMODINIT_FUNC initctrans(void) { (void) Py_InitModule3("ctrans", _ctransMethods, _ctransDoc); import_array(); // Must be present for NumPy. Called first after above line. }
PyMODINIT_FUNC initdecoders(void) { PyObject* m; decoders_FlacDecoderType.tp_new = PyType_GenericNew; if (PyType_Ready(&decoders_FlacDecoderType) < 0) return; decoders_OggFlacDecoderType.tp_new = PyType_GenericNew; if (PyType_Ready(&decoders_OggFlacDecoderType) < 0) return; decoders_SHNDecoderType.tp_new = PyType_GenericNew; if (PyType_Ready(&decoders_SHNDecoderType) < 0) return; decoders_ALACDecoderType.tp_new = PyType_GenericNew; if (PyType_Ready(&decoders_ALACDecoderType) < 0) return; decoders_WavPackDecoderType.tp_new = PyType_GenericNew; if (PyType_Ready(&decoders_WavPackDecoderType) < 0) return; #ifdef HAS_VORBIS decoders_VorbisDecoderType.tp_new = PyType_GenericNew; if (PyType_Ready(&decoders_VorbisDecoderType) < 0) return; #endif #ifdef HAS_MP3 decoders_MP3DecoderType.tp_new = PyType_GenericNew; if (PyType_Ready(&decoders_MP3DecoderType) < 0) return; #endif #ifdef HAS_OPUS decoders_OpusDecoderType.tp_new = PyType_GenericNew; if (PyType_Ready(&decoders_OpusDecoderType) < 0) return; #endif decoders_TTADecoderType.tp_new = PyType_GenericNew; if (PyType_Ready(&decoders_TTADecoderType) < 0) return; decoders_CPPMDecoderType.tp_new = PyType_GenericNew; if (PyType_Ready(&decoders_CPPMDecoderType) < 0) return; decoders_DVDA_Title_Type.tp_new = PyType_GenericNew; if (PyType_Ready(&decoders_DVDA_Title_Type) < 0) return; decoders_Sine_Mono_Type.tp_new = PyType_GenericNew; if (PyType_Ready(&decoders_Sine_Mono_Type) < 0) return; decoders_Sine_Stereo_Type.tp_new = PyType_GenericNew; if (PyType_Ready(&decoders_Sine_Stereo_Type) < 0) return; decoders_Sine_Simple_Type.tp_new = PyType_GenericNew; if (PyType_Ready(&decoders_Sine_Simple_Type) < 0) return; m = Py_InitModule3("decoders", module_methods, "Low-level audio format decoders"); Py_INCREF(&decoders_FlacDecoderType); PyModule_AddObject(m, "FlacDecoder", (PyObject *)&decoders_FlacDecoderType); Py_INCREF(&decoders_OggFlacDecoderType); PyModule_AddObject(m, "OggFlacDecoder", (PyObject *)&decoders_OggFlacDecoderType); Py_INCREF(&decoders_SHNDecoderType); PyModule_AddObject(m, "SHNDecoder", (PyObject *)&decoders_SHNDecoderType); Py_INCREF(&decoders_ALACDecoderType); PyModule_AddObject(m, "ALACDecoder", (PyObject *)&decoders_ALACDecoderType); Py_INCREF(&decoders_WavPackDecoderType); PyModule_AddObject(m, "WavPackDecoder", (PyObject *)&decoders_WavPackDecoderType); #ifdef HAS_VORBIS Py_INCREF(&decoders_VorbisDecoderType); PyModule_AddObject(m, "VorbisDecoder", (PyObject *)&decoders_VorbisDecoderType); #endif #ifdef HAS_MP3 Py_INCREF(&decoders_MP3DecoderType); PyModule_AddObject(m, "MP3Decoder", (PyObject *)&decoders_MP3DecoderType); #endif #ifdef HAS_OPUS Py_INCREF(&decoders_OpusDecoderType); PyModule_AddObject(m, "OpusDecoder", (PyObject *)&decoders_OpusDecoderType); #endif Py_INCREF(&decoders_TTADecoderType); PyModule_AddObject(m, "TTADecoder", (PyObject *)&decoders_TTADecoderType); Py_INCREF(&decoders_CPPMDecoderType); PyModule_AddObject(m, "CPPMDecoder", (PyObject *)&decoders_CPPMDecoderType); Py_INCREF(&decoders_DVDA_Title_Type); PyModule_AddObject(m, "DVDA_Title", (PyObject *)&decoders_DVDA_Title_Type); Py_INCREF(&decoders_Sine_Mono_Type); PyModule_AddObject(m, "Sine_Mono", (PyObject *)&decoders_Sine_Mono_Type); Py_INCREF(&decoders_Sine_Stereo_Type); PyModule_AddObject(m, "Sine_Stereo", (PyObject *)&decoders_Sine_Stereo_Type); Py_INCREF(&decoders_Sine_Simple_Type); PyModule_AddObject(m, "Sine_Simple", (PyObject *)&decoders_Sine_Simple_Type); #ifdef HAS_MP3 /*this initializes the library's static decoding tables although the library has an mpg123_exit() function to be called at shutdown-time, it's currenly a noop so we won't worry about it*/ mpg123_init(); #endif }
PyMODINIT_FUNC initalsacontrol(void) { PyObject *d, *d1, *l1, *o; int i; if (PyType_Ready(&pyalsacontrol_type) < 0) return; module = Py_InitModule3("alsacontrol", pyalsacontrolparse_methods, "libasound control wrapper"); if (module == NULL) return; #if 0 buildin = PyImport_AddModule("__buildin__"); if (buildin == NULL) return; if (PyObject_SetAttrString(module, "__buildins__", buildin) < 0) return; #endif Py_INCREF(&pyalsacontrol_type); PyModule_AddObject(module, "Control", (PyObject *)&pyalsacontrol_type); d = PyModule_GetDict(module); /* ---- */ d1 = PyDict_New(); #define add_space1(pname, name) { \ o = PyInt_FromLong(SND_CTL_ELEM_IFACE_##name); \ PyDict_SetItemString(d1, pname, o); \ Py_DECREF(o); } add_space1("CARD", CARD); add_space1("HWDEP", HWDEP); add_space1("MIXER", MIXER); add_space1("PCM", PCM); add_space1("RAWMIDI", RAWMIDI); add_space1("TIMER", TIMER); add_space1("SEQUENCER", SEQUENCER); add_space1("LAST", LAST); PyDict_SetItemString(d, "interface_id", d1); Py_DECREF(d1); /* ---- */ l1 = PyList_New(0); for (i = 0; i <= SND_CTL_ELEM_IFACE_LAST; i++) { o = PyString_FromString(snd_ctl_elem_iface_name(i)); PyList_Append(l1, o); Py_DECREF(o); } PyDict_SetItemString(d, "interface_name", l1); Py_DECREF(l1); /* ---- */ d1 = PyDict_New(); #define add_space5(pname, name) { \ o = PyInt_FromLong(SND_CTL_##name); \ PyDict_SetItemString(d1, pname, o); \ Py_DECREF(o); } add_space5("NONBLOCK", NONBLOCK); add_space5("ASYNC", ASYNC); add_space5("READONLY", READONLY); PyDict_SetItemString(d, "open_mode", d1); Py_DECREF(d1); /* ---- */ if (PyErr_Occurred()) Py_FatalError("Cannot initialize module alsacontrol"); }
PyMODINIT_FUNC PyInit_lua(void) { PyObject *m; #if PY_MAJOR_VERSION >= 3 if (PyType_Ready(&LuaObject_Type) < 0) return NULL; m = PyModule_Create(&lua_module); if (m == NULL) return NULL; #else if (PyType_Ready(&LuaObject_Type) < 0) return; m = Py_InitModule3("lua", lua_methods, "Lunatic-Python Python-Lua bridge"); if (m == NULL) return; #endif Py_INCREF(&LuaObject_Type); if (!LuaState) { #if defined(WIN32) FILE* file; char filename[_MAX_PATH]; char* slashptr; GetModuleFileName(GetModuleHandle("lua.pyd"), filename, _MAX_PATH); slashptr = strrchr(filename, '\\'); if (slashptr) { slashptr++; strcpy(slashptr, "lua.link"); file = fopen(filename, "r"); if (file) { char buffer[ MAX_PATH ]; if (fgets(buffer, sizeof(buffer), file) != NULL) { char *ptr = buffer + strlen(buffer) - 1; size_t len; while (ptr != buffer && (*ptr == '\n' || *ptr == '\r')) *ptr-- = 0; ++ptr; if (*ptr != '/' || *ptr != '\\') { *ptr++ = '/'; *ptr = 0; } if (buffer[0] == '/' || (buffer[1] && buffer[1] == ':')) strcpy(filename, buffer); else strcpy(slashptr, buffer); len = strlen(filename); #ifdef _DEBUG strcpy(filename + len, "lua51_debug.dll"); #else strcpy(filename + len, "lua51.dll"); #endif LoadLibrary(filename); } fclose(file); } } #endif /* WIN32 */ LuaState = luaL_newstate(); luaL_openlibs(LuaState); luaopen_python(LuaState); lua_settop(LuaState, 0); } #if PY_MAJOR_VERSION >= 3 return m; #endif }
void initcanv3d(void) { import_array(); Py_InitModule3("canv3d", canv3d_funcs, "Extension module example!"); }
/* Init */ void initdtw() { Py_InitModule3("dtw", dtw_methods, module_doc); import_array(); }
static PyObject* module_init(void) { PyObject *module, *ts_module, *capi; PyObject *copy_reg; if (init_strings() < 0) return NULL; #ifdef PY3K module = PyModule_Create(&moduledef); #else module = Py_InitModule3("cPersistence", cPersistence_methods, cPersistence_doc_string); #endif #ifdef PY3K ((PyObject*)&Pertype)->ob_type = &PyType_Type; #else Pertype.ob_type = &PyType_Type; #endif Pertype.tp_new = PyType_GenericNew; if (PyType_Ready(&Pertype) < 0) return NULL; if (PyModule_AddObject(module, "Persistent", (PyObject *)&Pertype) < 0) return NULL; cPersistenceCAPI = &truecPersistenceCAPI; #ifdef PY3K capi = PyCapsule_New(cPersistenceCAPI, CAPI_CAPSULE_NAME, NULL); #else capi = PyCObject_FromVoidPtr(cPersistenceCAPI, NULL); #endif if (!capi) return NULL; if (PyModule_AddObject(module, "CAPI", capi) < 0) return NULL; if (PyModule_AddIntConstant(module, "GHOST", cPersistent_GHOST_STATE) < 0) return NULL; if (PyModule_AddIntConstant(module, "UPTODATE", cPersistent_UPTODATE_STATE) < 0) return NULL; if (PyModule_AddIntConstant(module, "CHANGED", cPersistent_CHANGED_STATE) < 0) return NULL; if (PyModule_AddIntConstant(module, "STICKY", cPersistent_STICKY_STATE) < 0) return NULL; py_simple_new = PyObject_GetAttrString(module, "simple_new"); if (!py_simple_new) return NULL; #ifdef PY3K copy_reg = PyImport_ImportModule("copyreg"); #else copy_reg = PyImport_ImportModule("copy_reg"); #endif if (!copy_reg) return NULL; copy_reg_slotnames = PyObject_GetAttrString(copy_reg, "_slotnames"); if (!copy_reg_slotnames) { Py_DECREF(copy_reg); return NULL; } __newobj__ = PyObject_GetAttrString(copy_reg, "__newobj__"); if (!__newobj__) { Py_DECREF(copy_reg); return NULL; } if (!TimeStamp) { ts_module = PyImport_ImportModule("persistent.timestamp"); if (!ts_module) return NULL; TimeStamp = PyObject_GetAttrString(ts_module, "TimeStamp"); Py_DECREF(ts_module); /* fall through to immediate return on error */ } return module; }
PyMODINIT_FUNC initmatematico( void ) { Py_InitModule3("matematico", matematico_methods, matematico__doc__ ); }
void initns1(void) { Py_InitModule3("ns1", methods, pyns1_doc); }
initpycurl(void) #endif { PyObject *m, *d; const curl_version_info_data *vi; const char *libcurl_version, *runtime_ssl_lib; int libcurl_version_len, pycurl_version_len; /* Check the version, as this has caused nasty problems in * some cases. */ vi = curl_version_info(CURLVERSION_NOW); if (vi == NULL) { PyErr_SetString(PyExc_ImportError, "pycurl: curl_version_info() failed"); PYCURL_MODINIT_RETURN_NULL; } if (vi->version_num < LIBCURL_VERSION_NUM) { PyErr_Format(PyExc_ImportError, "pycurl: libcurl link-time version (%s) is older than compile-time version (%s)", vi->version, LIBCURL_VERSION); PYCURL_MODINIT_RETURN_NULL; } /* Our compiled crypto locks should correspond to runtime ssl library. */ if (vi->ssl_version == NULL) { runtime_ssl_lib = "none/other"; } else if (!strncmp(vi->ssl_version, "OpenSSL/", 8)) { runtime_ssl_lib = "openssl"; } else if (!strncmp(vi->ssl_version, "GnuTLS/", 7)) { runtime_ssl_lib = "gnutls"; } else if (!strncmp(vi->ssl_version, "NSS/", 4)) { runtime_ssl_lib = "nss"; } else { runtime_ssl_lib = "none/other"; } if (strcmp(runtime_ssl_lib, COMPILE_SSL_LIB)) { PyErr_Format(PyExc_ImportError, "pycurl: libcurl link-time ssl backend (%s) is different from compile-time ssl backend (%s)", runtime_ssl_lib, COMPILE_SSL_LIB); PYCURL_MODINIT_RETURN_NULL; } /* Initialize the type of the new type objects here; doing it here * is required for portability to Windows without requiring C++. */ p_Curl_Type = &Curl_Type; p_CurlMulti_Type = &CurlMulti_Type; p_CurlShare_Type = &CurlShare_Type; Py_TYPE(&Curl_Type) = &PyType_Type; Py_TYPE(&CurlMulti_Type) = &PyType_Type; Py_TYPE(&CurlShare_Type) = &PyType_Type; /* Create the module and add the functions */ if (PyType_Ready(&Curl_Type) < 0) PYCURL_MODINIT_RETURN_NULL; if (PyType_Ready(&CurlMulti_Type) < 0) PYCURL_MODINIT_RETURN_NULL; if (PyType_Ready(&CurlShare_Type) < 0) PYCURL_MODINIT_RETURN_NULL; #if PY_MAJOR_VERSION >= 3 m = PyModule_Create(&curlmodule); if (m == NULL) return NULL; #else m = Py_InitModule3("pycurl", curl_methods, pycurl_module_doc); assert(m != NULL && PyModule_Check(m)); #endif /* Add error object to the module */ d = PyModule_GetDict(m); assert(d != NULL); ErrorObject = PyErr_NewException("pycurl.error", NULL, NULL); assert(ErrorObject != NULL); PyDict_SetItemString(d, "error", ErrorObject); curlobject_constants = PyDict_New(); assert(curlobject_constants != NULL); /* Add version strings to the module */ libcurl_version = curl_version(); libcurl_version_len = strlen(libcurl_version); #define PYCURL_VERSION_PREFIX_SIZE sizeof(PYCURL_VERSION_PREFIX) /* PYCURL_VERSION_PREFIX_SIZE includes terminating null which will be * replaced with the space; libcurl_version_len does not include * terminating null. */ pycurl_version_len = PYCURL_VERSION_PREFIX_SIZE + libcurl_version_len + 1; g_pycurl_useragent = PyMem_Malloc(pycurl_version_len); assert(g_pycurl_useragent != NULL); memcpy(g_pycurl_useragent, PYCURL_VERSION_PREFIX, PYCURL_VERSION_PREFIX_SIZE); g_pycurl_useragent[PYCURL_VERSION_PREFIX_SIZE-1] = ' '; memcpy(g_pycurl_useragent + PYCURL_VERSION_PREFIX_SIZE, libcurl_version, libcurl_version_len); g_pycurl_useragent[pycurl_version_len - 1] = 0; #undef PYCURL_VERSION_PREFIX_SIZE insobj2(d, NULL, "version", PyText_FromString(g_pycurl_useragent)); insstr(d, "COMPILE_DATE", __DATE__ " " __TIME__); insint(d, "COMPILE_PY_VERSION_HEX", PY_VERSION_HEX); insint(d, "COMPILE_LIBCURL_VERSION_NUM", LIBCURL_VERSION_NUM); /* Types */ insobj2(d, NULL, "Curl", (PyObject *) p_Curl_Type); insobj2(d, NULL, "CurlMulti", (PyObject *) p_CurlMulti_Type); insobj2(d, NULL, "CurlShare", (PyObject *) p_CurlShare_Type); /** ** the order of these constants mostly follows <curl/curl.h> **/ /* Abort curl_read_callback(). */ insint_c(d, "READFUNC_ABORT", CURL_READFUNC_ABORT); insint_c(d, "READFUNC_PAUSE", CURL_READFUNC_PAUSE); /* Pause curl_write_callback(). */ insint_c(d, "WRITEFUNC_PAUSE", CURL_WRITEFUNC_PAUSE); /* constants for ioctl callback return values */ insint_c(d, "IOE_OK", CURLIOE_OK); insint_c(d, "IOE_UNKNOWNCMD", CURLIOE_UNKNOWNCMD); insint_c(d, "IOE_FAILRESTART", CURLIOE_FAILRESTART); /* constants for ioctl callback argument values */ insint_c(d, "IOCMD_NOP", CURLIOCMD_NOP); insint_c(d, "IOCMD_RESTARTREAD", CURLIOCMD_RESTARTREAD); /* curl_infotype: the kind of data that is passed to information_callback */ /* XXX do we actually need curl_infotype in pycurl ??? */ insint_c(d, "INFOTYPE_TEXT", CURLINFO_TEXT); insint_c(d, "INFOTYPE_HEADER_IN", CURLINFO_HEADER_IN); insint_c(d, "INFOTYPE_HEADER_OUT", CURLINFO_HEADER_OUT); insint_c(d, "INFOTYPE_DATA_IN", CURLINFO_DATA_IN); insint_c(d, "INFOTYPE_DATA_OUT", CURLINFO_DATA_OUT); insint_c(d, "INFOTYPE_SSL_DATA_IN", CURLINFO_SSL_DATA_IN); insint_c(d, "INFOTYPE_SSL_DATA_OUT", CURLINFO_SSL_DATA_OUT); /* CURLcode: error codes */ insint_c(d, "E_OK", CURLE_OK); insint_c(d, "E_UNSUPPORTED_PROTOCOL", CURLE_UNSUPPORTED_PROTOCOL); insint_c(d, "E_FAILED_INIT", CURLE_FAILED_INIT); insint_c(d, "E_URL_MALFORMAT", CURLE_URL_MALFORMAT); #ifdef HAVE_CURL_7_21_5 insint_c(d, "E_NOT_BUILT_IN", CURLE_NOT_BUILT_IN); #endif insint_c(d, "E_COULDNT_RESOLVE_PROXY", CURLE_COULDNT_RESOLVE_PROXY); insint_c(d, "E_COULDNT_RESOLVE_HOST", CURLE_COULDNT_RESOLVE_HOST); insint_c(d, "E_COULDNT_CONNECT", CURLE_COULDNT_CONNECT); insint_c(d, "E_FTP_WEIRD_SERVER_REPLY", CURLE_FTP_WEIRD_SERVER_REPLY); insint_c(d, "E_FTP_ACCESS_DENIED", CURLE_FTP_ACCESS_DENIED); #ifdef HAVE_CURL_7_24_0 insint_c(d, "E_FTP_ACCEPT_FAILED", CURLE_FTP_ACCEPT_FAILED); #endif insint_c(d, "E_FTP_WEIRD_PASS_REPLY", CURLE_FTP_WEIRD_PASS_REPLY); insint_c(d, "E_FTP_WEIRD_USER_REPLY", CURLE_FTP_WEIRD_USER_REPLY); insint_c(d, "E_FTP_WEIRD_PASV_REPLY", CURLE_FTP_WEIRD_PASV_REPLY); insint_c(d, "E_FTP_WEIRD_227_FORMAT", CURLE_FTP_WEIRD_227_FORMAT); insint_c(d, "E_FTP_CANT_GET_HOST", CURLE_FTP_CANT_GET_HOST); insint_c(d, "E_FTP_CANT_RECONNECT", CURLE_FTP_CANT_RECONNECT); insint_c(d, "E_FTP_COULDNT_SET_BINARY", CURLE_FTP_COULDNT_SET_BINARY); insint_c(d, "E_PARTIAL_FILE", CURLE_PARTIAL_FILE); insint_c(d, "E_FTP_COULDNT_RETR_FILE", CURLE_FTP_COULDNT_RETR_FILE); insint_c(d, "E_FTP_WRITE_ERROR", CURLE_FTP_WRITE_ERROR); insint_c(d, "E_FTP_QUOTE_ERROR", CURLE_FTP_QUOTE_ERROR); insint_c(d, "E_HTTP_RETURNED_ERROR", CURLE_HTTP_RETURNED_ERROR); insint_c(d, "E_WRITE_ERROR", CURLE_WRITE_ERROR); insint_c(d, "E_FTP_COULDNT_STOR_FILE", CURLE_FTP_COULDNT_STOR_FILE); insint_c(d, "E_READ_ERROR", CURLE_READ_ERROR); insint_c(d, "E_OUT_OF_MEMORY", CURLE_OUT_OF_MEMORY); insint_c(d, "E_OPERATION_TIMEOUTED", CURLE_OPERATION_TIMEOUTED); insint_c(d, "E_OPERATION_TIMEDOUT", CURLE_OPERATION_TIMEDOUT); insint_c(d, "E_FTP_COULDNT_SET_ASCII", CURLE_FTP_COULDNT_SET_ASCII); insint_c(d, "E_FTP_PORT_FAILED", CURLE_FTP_PORT_FAILED); insint_c(d, "E_FTP_COULDNT_USE_REST", CURLE_FTP_COULDNT_USE_REST); insint_c(d, "E_FTP_COULDNT_GET_SIZE", CURLE_FTP_COULDNT_GET_SIZE); insint_c(d, "E_HTTP_RANGE_ERROR", CURLE_HTTP_RANGE_ERROR); insint_c(d, "E_HTTP_POST_ERROR", CURLE_HTTP_POST_ERROR); insint_c(d, "E_SSL_CONNECT_ERROR", CURLE_SSL_CONNECT_ERROR); insint_c(d, "E_BAD_DOWNLOAD_RESUME", CURLE_BAD_DOWNLOAD_RESUME); insint_c(d, "E_FILE_COULDNT_READ_FILE", CURLE_FILE_COULDNT_READ_FILE); insint_c(d, "E_LDAP_CANNOT_BIND", CURLE_LDAP_CANNOT_BIND); insint_c(d, "E_LDAP_SEARCH_FAILED", CURLE_LDAP_SEARCH_FAILED); insint_c(d, "E_LIBRARY_NOT_FOUND", CURLE_LIBRARY_NOT_FOUND); insint_c(d, "E_FUNCTION_NOT_FOUND", CURLE_FUNCTION_NOT_FOUND); insint_c(d, "E_ABORTED_BY_CALLBACK", CURLE_ABORTED_BY_CALLBACK); insint_c(d, "E_BAD_FUNCTION_ARGUMENT", CURLE_BAD_FUNCTION_ARGUMENT); insint_c(d, "E_INTERFACE_FAILED", CURLE_INTERFACE_FAILED); insint_c(d, "E_TOO_MANY_REDIRECTS", CURLE_TOO_MANY_REDIRECTS); #ifdef HAVE_CURL_7_21_5 insint_c(d, "E_UNKNOWN_OPTION", CURLE_UNKNOWN_OPTION); #endif /* same as E_UNKNOWN_OPTION */ insint_c(d, "E_UNKNOWN_TELNET_OPTION", CURLE_UNKNOWN_TELNET_OPTION); insint_c(d, "E_TELNET_OPTION_SYNTAX", CURLE_TELNET_OPTION_SYNTAX); insint_c(d, "E_SSL_PEER_CERTIFICATE", CURLE_SSL_PEER_CERTIFICATE); insint_c(d, "E_GOT_NOTHING", CURLE_GOT_NOTHING); insint_c(d, "E_SSL_ENGINE_NOTFOUND", CURLE_SSL_ENGINE_NOTFOUND); insint_c(d, "E_SSL_ENGINE_SETFAILED", CURLE_SSL_ENGINE_SETFAILED); insint_c(d, "E_SEND_ERROR", CURLE_SEND_ERROR); insint_c(d, "E_RECV_ERROR", CURLE_RECV_ERROR); insint_c(d, "E_SHARE_IN_USE", CURLE_SHARE_IN_USE); insint_c(d, "E_SSL_CERTPROBLEM", CURLE_SSL_CERTPROBLEM); insint_c(d, "E_SSL_CIPHER", CURLE_SSL_CIPHER); insint_c(d, "E_SSL_CACERT", CURLE_SSL_CACERT); insint_c(d, "E_BAD_CONTENT_ENCODING", CURLE_BAD_CONTENT_ENCODING); insint_c(d, "E_LDAP_INVALID_URL", CURLE_LDAP_INVALID_URL); insint_c(d, "E_FILESIZE_EXCEEDED", CURLE_FILESIZE_EXCEEDED); insint_c(d, "E_FTP_SSL_FAILED", CURLE_FTP_SSL_FAILED); insint_c(d, "E_SEND_FAIL_REWIND", CURLE_SEND_FAIL_REWIND); insint_c(d, "E_SSL_ENGINE_INITFAILED", CURLE_SSL_ENGINE_INITFAILED); insint_c(d, "E_LOGIN_DENIED", CURLE_LOGIN_DENIED); insint_c(d, "E_TFTP_NOTFOUND", CURLE_TFTP_NOTFOUND); insint_c(d, "E_TFTP_PERM", CURLE_TFTP_PERM); insint_c(d, "E_TFTP_DISKFULL", CURLE_TFTP_DISKFULL); insint_c(d, "E_TFTP_ILLEGAL", CURLE_TFTP_ILLEGAL); insint_c(d, "E_TFTP_UNKNOWNID", CURLE_TFTP_UNKNOWNID); insint_c(d, "E_TFTP_EXISTS", CURLE_TFTP_EXISTS); insint_c(d, "E_TFTP_NOSUCHUSER", CURLE_TFTP_NOSUCHUSER); insint_c(d, "E_CONV_FAILED", CURLE_CONV_FAILED); insint_c(d, "E_CONV_REQD", CURLE_CONV_REQD); insint_c(d, "E_SSL_CACERT_BADFILE", CURLE_SSL_CACERT_BADFILE); insint_c(d, "E_REMOTE_FILE_NOT_FOUND", CURLE_REMOTE_FILE_NOT_FOUND); insint_c(d, "E_SSH", CURLE_SSH); insint_c(d, "E_SSL_SHUTDOWN_FAILED", CURLE_SSL_SHUTDOWN_FAILED); /* curl_proxytype: constants for setopt(PROXYTYPE, x) */ insint_c(d, "PROXYTYPE_HTTP", CURLPROXY_HTTP); #ifdef HAVE_CURL_7_19_4_OPTS insint_c(d, "PROXYTYPE_HTTP_1_0", CURLPROXY_HTTP_1_0); #endif insint_c(d, "PROXYTYPE_SOCKS4", CURLPROXY_SOCKS4); insint_c(d, "PROXYTYPE_SOCKS5", CURLPROXY_SOCKS5); /* curl_httpauth: constants for setopt(HTTPAUTH, x) */ insint_c(d, "HTTPAUTH_NONE", CURLAUTH_NONE); insint_c(d, "HTTPAUTH_BASIC", CURLAUTH_BASIC); insint_c(d, "HTTPAUTH_DIGEST", CURLAUTH_DIGEST); #ifdef HAVE_CURLAUTH_DIGEST_IE insint_c(d, "HTTPAUTH_DIGEST_IE", CURLAUTH_DIGEST_IE); #endif insint_c(d, "HTTPAUTH_GSSNEGOTIATE", CURLAUTH_GSSNEGOTIATE); insint_c(d, "HTTPAUTH_NTLM", CURLAUTH_NTLM); insint_c(d, "HTTPAUTH_ANY", CURLAUTH_ANY); insint_c(d, "HTTPAUTH_ANYSAFE", CURLAUTH_ANYSAFE); /* curl_ftpssl: constants for setopt(FTP_SSL, x) */ insint_c(d, "FTPSSL_NONE", CURLFTPSSL_NONE); insint_c(d, "FTPSSL_TRY", CURLFTPSSL_TRY); insint_c(d, "FTPSSL_CONTROL", CURLFTPSSL_CONTROL); insint_c(d, "FTPSSL_ALL", CURLFTPSSL_ALL); /* curl_ftpauth: constants for setopt(FTPSSLAUTH, x) */ insint_c(d, "FTPAUTH_DEFAULT", CURLFTPAUTH_DEFAULT); insint_c(d, "FTPAUTH_SSL", CURLFTPAUTH_SSL); insint_c(d, "FTPAUTH_TLS", CURLFTPAUTH_TLS); /* curl_ftpauth: constants for setopt(FTPSSLAUTH, x) */ insint_c(d, "FORM_BUFFER", CURLFORM_BUFFER); insint_c(d, "FORM_BUFFERPTR", CURLFORM_BUFFERPTR); insint_c(d, "FORM_CONTENTS", CURLFORM_COPYCONTENTS); insint_c(d, "FORM_FILE", CURLFORM_FILE); insint_c(d, "FORM_CONTENTTYPE", CURLFORM_CONTENTTYPE); insint_c(d, "FORM_FILENAME", CURLFORM_FILENAME); /* FTP_FILEMETHOD options */ insint_c(d, "FTPMETHOD_DEFAULT", CURLFTPMETHOD_DEFAULT); insint_c(d, "FTPMETHOD_MULTICWD", CURLFTPMETHOD_MULTICWD); insint_c(d, "FTPMETHOD_NOCWD", CURLFTPMETHOD_NOCWD); insint_c(d, "FTPMETHOD_SINGLECWD", CURLFTPMETHOD_SINGLECWD); /* CURLoption: symbolic constants for setopt() */ /* FIXME: reorder these to match <curl/curl.h> */ insint_c(d, "FILE", CURLOPT_WRITEDATA); insint_c(d, "URL", CURLOPT_URL); insint_c(d, "PORT", CURLOPT_PORT); insint_c(d, "PROXY", CURLOPT_PROXY); insint_c(d, "USERPWD", CURLOPT_USERPWD); #ifdef HAVE_CURLOPT_USERNAME insint_c(d, "USERNAME", CURLOPT_USERNAME); insint_c(d, "PASSWORD", CURLOPT_PASSWORD); #endif insint_c(d, "PROXYUSERPWD", CURLOPT_PROXYUSERPWD); #ifdef HAVE_CURLOPT_PROXYUSERNAME insint_c(d, "PROXYUSERNAME", CURLOPT_PROXYUSERNAME); insint_c(d, "PROXYPASSWORD", CURLOPT_PROXYPASSWORD); #endif insint_c(d, "RANGE", CURLOPT_RANGE); insint_c(d, "INFILE", CURLOPT_READDATA); /* ERRORBUFFER is not supported */ insint_c(d, "WRITEFUNCTION", CURLOPT_WRITEFUNCTION); insint_c(d, "READFUNCTION", CURLOPT_READFUNCTION); insint_c(d, "TIMEOUT", CURLOPT_TIMEOUT); insint_c(d, "INFILESIZE", CURLOPT_INFILESIZE_LARGE); /* _LARGE ! */ insint_c(d, "POSTFIELDS", CURLOPT_POSTFIELDS); insint_c(d, "REFERER", CURLOPT_REFERER); insint_c(d, "FTPPORT", CURLOPT_FTPPORT); insint_c(d, "USERAGENT", CURLOPT_USERAGENT); insint_c(d, "LOW_SPEED_LIMIT", CURLOPT_LOW_SPEED_LIMIT); insint_c(d, "LOW_SPEED_TIME", CURLOPT_LOW_SPEED_TIME); insint_c(d, "RESUME_FROM", CURLOPT_RESUME_FROM_LARGE); /* _LARGE ! */ insint_c(d, "WRITEDATA", CURLOPT_WRITEDATA); insint_c(d, "READDATA", CURLOPT_READDATA); insint_c(d, "PROXYPORT", CURLOPT_PROXYPORT); insint_c(d, "HTTPPROXYTUNNEL", CURLOPT_HTTPPROXYTUNNEL); insint_c(d, "VERBOSE", CURLOPT_VERBOSE); insint_c(d, "HEADER", CURLOPT_HEADER); insint_c(d, "NOPROGRESS", CURLOPT_NOPROGRESS); insint_c(d, "NOBODY", CURLOPT_NOBODY); insint_c(d, "FAILONERROR", CURLOPT_FAILONERROR); insint_c(d, "UPLOAD", CURLOPT_UPLOAD); insint_c(d, "POST", CURLOPT_POST); insint_c(d, "FTPLISTONLY", CURLOPT_FTPLISTONLY); insint_c(d, "FTPAPPEND", CURLOPT_FTPAPPEND); insint_c(d, "NETRC", CURLOPT_NETRC); insint_c(d, "FOLLOWLOCATION", CURLOPT_FOLLOWLOCATION); insint_c(d, "TRANSFERTEXT", CURLOPT_TRANSFERTEXT); insint_c(d, "PUT", CURLOPT_PUT); insint_c(d, "POSTFIELDSIZE", CURLOPT_POSTFIELDSIZE_LARGE); /* _LARGE ! */ insint_c(d, "COOKIE", CURLOPT_COOKIE); insint_c(d, "HTTPHEADER", CURLOPT_HTTPHEADER); insint_c(d, "HTTPPOST", CURLOPT_HTTPPOST); insint_c(d, "SSLCERT", CURLOPT_SSLCERT); insint_c(d, "SSLCERTPASSWD", CURLOPT_SSLCERTPASSWD); insint_c(d, "CRLF", CURLOPT_CRLF); insint_c(d, "QUOTE", CURLOPT_QUOTE); insint_c(d, "POSTQUOTE", CURLOPT_POSTQUOTE); insint_c(d, "PREQUOTE", CURLOPT_PREQUOTE); insint_c(d, "WRITEHEADER", CURLOPT_WRITEHEADER); insint_c(d, "HEADERFUNCTION", CURLOPT_HEADERFUNCTION); insint_c(d, "SEEKFUNCTION", CURLOPT_SEEKFUNCTION); insint_c(d, "COOKIEFILE", CURLOPT_COOKIEFILE); insint_c(d, "SSLVERSION", CURLOPT_SSLVERSION); insint_c(d, "TIMECONDITION", CURLOPT_TIMECONDITION); insint_c(d, "TIMEVALUE", CURLOPT_TIMEVALUE); insint_c(d, "CUSTOMREQUEST", CURLOPT_CUSTOMREQUEST); insint_c(d, "STDERR", CURLOPT_STDERR); insint_c(d, "INTERFACE", CURLOPT_INTERFACE); insint_c(d, "KRB4LEVEL", CURLOPT_KRB4LEVEL); insint_c(d, "PROGRESSFUNCTION", CURLOPT_PROGRESSFUNCTION); insint_c(d, "SSL_VERIFYPEER", CURLOPT_SSL_VERIFYPEER); insint_c(d, "CAPATH", CURLOPT_CAPATH); insint_c(d, "CAINFO", CURLOPT_CAINFO); insint_c(d, "OPT_FILETIME", CURLOPT_FILETIME); insint_c(d, "MAXREDIRS", CURLOPT_MAXREDIRS); insint_c(d, "MAXCONNECTS", CURLOPT_MAXCONNECTS); insint_c(d, "FRESH_CONNECT", CURLOPT_FRESH_CONNECT); insint_c(d, "FORBID_REUSE", CURLOPT_FORBID_REUSE); insint_c(d, "RANDOM_FILE", CURLOPT_RANDOM_FILE); insint_c(d, "EGDSOCKET", CURLOPT_EGDSOCKET); insint_c(d, "CONNECTTIMEOUT", CURLOPT_CONNECTTIMEOUT); insint_c(d, "HTTPGET", CURLOPT_HTTPGET); insint_c(d, "SSL_VERIFYHOST", CURLOPT_SSL_VERIFYHOST); insint_c(d, "COOKIEJAR", CURLOPT_COOKIEJAR); insint_c(d, "SSL_CIPHER_LIST", CURLOPT_SSL_CIPHER_LIST); insint_c(d, "HTTP_VERSION", CURLOPT_HTTP_VERSION); insint_c(d, "FTP_USE_EPSV", CURLOPT_FTP_USE_EPSV); insint_c(d, "SSLCERTTYPE", CURLOPT_SSLCERTTYPE); insint_c(d, "SSLKEY", CURLOPT_SSLKEY); insint_c(d, "SSLKEYTYPE", CURLOPT_SSLKEYTYPE); insint_c(d, "SSLKEYPASSWD", CURLOPT_SSLKEYPASSWD); insint_c(d, "SSLENGINE", CURLOPT_SSLENGINE); insint_c(d, "SSLENGINE_DEFAULT", CURLOPT_SSLENGINE_DEFAULT); insint_c(d, "DNS_CACHE_TIMEOUT", CURLOPT_DNS_CACHE_TIMEOUT); insint_c(d, "DNS_USE_GLOBAL_CACHE", CURLOPT_DNS_USE_GLOBAL_CACHE); insint_c(d, "DEBUGFUNCTION", CURLOPT_DEBUGFUNCTION); insint_c(d, "BUFFERSIZE", CURLOPT_BUFFERSIZE); insint_c(d, "NOSIGNAL", CURLOPT_NOSIGNAL); insint_c(d, "SHARE", CURLOPT_SHARE); insint_c(d, "PROXYTYPE", CURLOPT_PROXYTYPE); insint_c(d, "ENCODING", CURLOPT_ENCODING); insint_c(d, "HTTP200ALIASES", CURLOPT_HTTP200ALIASES); insint_c(d, "UNRESTRICTED_AUTH", CURLOPT_UNRESTRICTED_AUTH); insint_c(d, "FTP_USE_EPRT", CURLOPT_FTP_USE_EPRT); insint_c(d, "HTTPAUTH", CURLOPT_HTTPAUTH); insint_c(d, "FTP_CREATE_MISSING_DIRS", CURLOPT_FTP_CREATE_MISSING_DIRS); insint_c(d, "PROXYAUTH", CURLOPT_PROXYAUTH); insint_c(d, "FTP_RESPONSE_TIMEOUT", CURLOPT_FTP_RESPONSE_TIMEOUT); insint_c(d, "IPRESOLVE", CURLOPT_IPRESOLVE); insint_c(d, "MAXFILESIZE", CURLOPT_MAXFILESIZE_LARGE); /* _LARGE ! */ insint_c(d, "INFILESIZE_LARGE", CURLOPT_INFILESIZE_LARGE); insint_c(d, "RESUME_FROM_LARGE", CURLOPT_RESUME_FROM_LARGE); insint_c(d, "MAXFILESIZE_LARGE", CURLOPT_MAXFILESIZE_LARGE); insint_c(d, "NETRC_FILE", CURLOPT_NETRC_FILE); insint_c(d, "FTP_SSL", CURLOPT_FTP_SSL); insint_c(d, "POSTFIELDSIZE_LARGE", CURLOPT_POSTFIELDSIZE_LARGE); insint_c(d, "TCP_NODELAY", CURLOPT_TCP_NODELAY); insint_c(d, "FTPSSLAUTH", CURLOPT_FTPSSLAUTH); insint_c(d, "IOCTLFUNCTION", CURLOPT_IOCTLFUNCTION); insint_c(d, "IOCTLDATA", CURLOPT_IOCTLDATA); insint_c(d, "OPENSOCKETFUNCTION", CURLOPT_OPENSOCKETFUNCTION); insint_c(d, "FTP_ACCOUNT", CURLOPT_FTP_ACCOUNT); insint_c(d, "IGNORE_CONTENT_LENGTH", CURLOPT_IGNORE_CONTENT_LENGTH); insint_c(d, "COOKIELIST", CURLOPT_COOKIELIST); insint_c(d, "FTP_SKIP_PASV_IP", CURLOPT_FTP_SKIP_PASV_IP); insint_c(d, "FTP_FILEMETHOD", CURLOPT_FTP_FILEMETHOD); insint_c(d, "CONNECT_ONLY", CURLOPT_CONNECT_ONLY); insint_c(d, "LOCALPORT", CURLOPT_LOCALPORT); insint_c(d, "LOCALPORTRANGE", CURLOPT_LOCALPORTRANGE); insint_c(d, "FTP_ALTERNATIVE_TO_USER", CURLOPT_FTP_ALTERNATIVE_TO_USER); insint_c(d, "MAX_SEND_SPEED_LARGE", CURLOPT_MAX_SEND_SPEED_LARGE); insint_c(d, "MAX_RECV_SPEED_LARGE", CURLOPT_MAX_RECV_SPEED_LARGE); insint_c(d, "SSL_SESSIONID_CACHE", CURLOPT_SSL_SESSIONID_CACHE); insint_c(d, "SSH_AUTH_TYPES", CURLOPT_SSH_AUTH_TYPES); insint_c(d, "SSH_PUBLIC_KEYFILE", CURLOPT_SSH_PUBLIC_KEYFILE); insint_c(d, "SSH_PRIVATE_KEYFILE", CURLOPT_SSH_PRIVATE_KEYFILE); #ifdef HAVE_CURL_7_19_6_OPTS insint_c(d, "SSH_KNOWNHOSTS", CURLOPT_SSH_KNOWNHOSTS); #endif insint_c(d, "FTP_SSL_CCC", CURLOPT_FTP_SSL_CCC); insint_c(d, "TIMEOUT_MS", CURLOPT_TIMEOUT_MS); insint_c(d, "CONNECTTIMEOUT_MS", CURLOPT_CONNECTTIMEOUT_MS); insint_c(d, "HTTP_TRANSFER_DECODING", CURLOPT_HTTP_TRANSFER_DECODING); insint_c(d, "HTTP_CONTENT_DECODING", CURLOPT_HTTP_CONTENT_DECODING); insint_c(d, "NEW_FILE_PERMS", CURLOPT_NEW_FILE_PERMS); insint_c(d, "NEW_DIRECTORY_PERMS", CURLOPT_NEW_DIRECTORY_PERMS); insint_c(d, "POST301", CURLOPT_POST301); insint_c(d, "PROXY_TRANSFER_MODE", CURLOPT_PROXY_TRANSFER_MODE); insint_c(d, "COPYPOSTFIELDS", CURLOPT_COPYPOSTFIELDS); insint_c(d, "SSH_HOST_PUBLIC_KEY_MD5", CURLOPT_SSH_HOST_PUBLIC_KEY_MD5); insint_c(d, "AUTOREFERER", CURLOPT_AUTOREFERER); insint_c(d, "CRLFILE", CURLOPT_CRLFILE); insint_c(d, "ISSUERCERT", CURLOPT_ISSUERCERT); insint_c(d, "ADDRESS_SCOPE", CURLOPT_ADDRESS_SCOPE); #ifdef HAVE_CURLOPT_RESOLVE insint_c(d, "RESOLVE", CURLOPT_RESOLVE); #endif #ifdef HAVE_CURLOPT_CERTINFO insint_c(d, "OPT_CERTINFO", CURLOPT_CERTINFO); #endif #ifdef HAVE_CURLOPT_POSTREDIR insint_c(d, "POSTREDIR", CURLOPT_POSTREDIR); #endif #ifdef HAVE_CURLOPT_NOPROXY insint_c(d, "NOPROXY", CURLOPT_NOPROXY); #endif #ifdef HAVE_CURLOPT_PROTOCOLS insint_c(d, "PROTOCOLS", CURLOPT_PROTOCOLS); insint_c(d, "REDIR_PROTOCOLS", CURLOPT_REDIR_PROTOCOLS); insint_c(d, "PROTO_HTTP", CURLPROTO_HTTP); insint_c(d, "PROTO_HTTPS", CURLPROTO_HTTPS); insint_c(d, "PROTO_FTP", CURLPROTO_FTP); insint_c(d, "PROTO_FTPS", CURLPROTO_FTPS); insint_c(d, "PROTO_SCP", CURLPROTO_SCP); insint_c(d, "PROTO_SFTP", CURLPROTO_SFTP); insint_c(d, "PROTO_TELNET", CURLPROTO_TELNET); insint_c(d, "PROTO_LDAP", CURLPROTO_LDAP); insint_c(d, "PROTO_LDAPS", CURLPROTO_LDAPS); insint_c(d, "PROTO_DICT", CURLPROTO_DICT); insint_c(d, "PROTO_FILE", CURLPROTO_FILE); insint_c(d, "PROTO_TFTP", CURLPROTO_TFTP); insint_c(d, "PROTO_IMAP", CURLPROTO_IMAP); insint_c(d, "PROTO_IMAPS", CURLPROTO_IMAPS); insint_c(d, "PROTO_POP3", CURLPROTO_POP3); insint_c(d, "PROTO_POP3S", CURLPROTO_POP3S); insint_c(d, "PROTO_SMTP", CURLPROTO_SMTP); insint_c(d, "PROTO_SMTPS", CURLPROTO_SMTPS); insint_c(d, "PROTO_RTSP", CURLPROTO_RTSP); insint_c(d, "PROTO_RTMP", CURLPROTO_RTMP); insint_c(d, "PROTO_RTMPT", CURLPROTO_RTMPT); insint_c(d, "PROTO_RTMPE", CURLPROTO_RTMPE); insint_c(d, "PROTO_RTMPTE", CURLPROTO_RTMPTE); insint_c(d, "PROTO_RTMPS", CURLPROTO_RTMPS); insint_c(d, "PROTO_RTMPTS", CURLPROTO_RTMPTS); insint_c(d, "PROTO_GOPHER", CURLPROTO_GOPHER); insint_c(d, "PROTO_ALL", CURLPROTO_ALL); #endif #ifdef HAVE_CURL_7_19_4_OPTS insint_c(d, "TFTP_BLKSIZE", CURLOPT_TFTP_BLKSIZE); insint_c(d, "SOCKS5_GSSAPI_SERVICE", CURLOPT_SOCKS5_GSSAPI_SERVICE); insint_c(d, "SOCKS5_GSSAPI_NEC", CURLOPT_SOCKS5_GSSAPI_NEC); #endif insint_c(d, "M_TIMERFUNCTION", CURLMOPT_TIMERFUNCTION); insint_c(d, "M_SOCKETFUNCTION", CURLMOPT_SOCKETFUNCTION); insint_c(d, "M_PIPELINING", CURLMOPT_PIPELINING); insint_c(d, "M_MAXCONNECTS", CURLMOPT_MAXCONNECTS); #ifdef HAVE_CURL_7_30_0_PIPELINE_OPTS insint_c(d, "M_MAX_HOST_CONNECTIONS", CURLMOPT_MAX_HOST_CONNECTIONS); insint_c(d, "M_MAX_TOTAL_CONNECTIONS", CURLMOPT_MAX_TOTAL_CONNECTIONS); insint_c(d, "M_MAX_PIPELINE_LENGTH", CURLMOPT_MAX_PIPELINE_LENGTH); insint_c(d, "M_CONTENT_LENGTH_PENALTY_SIZE", CURLMOPT_CONTENT_LENGTH_PENALTY_SIZE); insint_c(d, "M_CHUNK_LENGTH_PENALTY_SIZE", CURLMOPT_CHUNK_LENGTH_PENALTY_SIZE); #endif /* constants for setopt(IPRESOLVE, x) */ insint_c(d, "IPRESOLVE_WHATEVER", CURL_IPRESOLVE_WHATEVER); insint_c(d, "IPRESOLVE_V4", CURL_IPRESOLVE_V4); insint_c(d, "IPRESOLVE_V6", CURL_IPRESOLVE_V6); /* constants for setopt(HTTP_VERSION, x) */ insint_c(d, "CURL_HTTP_VERSION_NONE", CURL_HTTP_VERSION_NONE); insint_c(d, "CURL_HTTP_VERSION_1_0", CURL_HTTP_VERSION_1_0); insint_c(d, "CURL_HTTP_VERSION_1_1", CURL_HTTP_VERSION_1_1); insint_c(d, "CURL_HTTP_VERSION_LAST", CURL_HTTP_VERSION_LAST); /* CURL_NETRC_OPTION: constants for setopt(NETRC, x) */ insint_c(d, "NETRC_OPTIONAL", CURL_NETRC_OPTIONAL); insint_c(d, "NETRC_IGNORED", CURL_NETRC_IGNORED); insint_c(d, "NETRC_REQUIRED", CURL_NETRC_REQUIRED); /* constants for setopt(SSLVERSION, x) */ insint_c(d, "SSLVERSION_DEFAULT", CURL_SSLVERSION_DEFAULT); insint_c(d, "SSLVERSION_TLSv1", CURL_SSLVERSION_TLSv1); insint_c(d, "SSLVERSION_SSLv2", CURL_SSLVERSION_SSLv2); insint_c(d, "SSLVERSION_SSLv3", CURL_SSLVERSION_SSLv3); /* curl_TimeCond: constants for setopt(TIMECONDITION, x) */ insint_c(d, "TIMECONDITION_NONE", CURL_TIMECOND_NONE); insint_c(d, "TIMECONDITION_IFMODSINCE", CURL_TIMECOND_IFMODSINCE); insint_c(d, "TIMECONDITION_IFUNMODSINCE", CURL_TIMECOND_IFUNMODSINCE); insint_c(d, "TIMECONDITION_LASTMOD", CURL_TIMECOND_LASTMOD); /* constants for setopt(CURLOPT_SSH_AUTH_TYPES, x) */ insint_c(d, "SSH_AUTH_ANY", CURLSSH_AUTH_ANY); insint_c(d, "SSH_AUTH_NONE", CURLSSH_AUTH_NONE); insint_c(d, "SSH_AUTH_PUBLICKEY", CURLSSH_AUTH_PUBLICKEY); insint_c(d, "SSH_AUTH_PASSWORD", CURLSSH_AUTH_PASSWORD); insint_c(d, "SSH_AUTH_HOST", CURLSSH_AUTH_HOST); insint_c(d, "SSH_AUTH_KEYBOARD", CURLSSH_AUTH_KEYBOARD); insint_c(d, "SSH_AUTH_DEFAULT", CURLSSH_AUTH_DEFAULT); /* CURLINFO: symbolic constants for getinfo(x) */ insint_c(d, "EFFECTIVE_URL", CURLINFO_EFFECTIVE_URL); insint_c(d, "HTTP_CODE", CURLINFO_HTTP_CODE); insint_c(d, "RESPONSE_CODE", CURLINFO_HTTP_CODE); insint_c(d, "TOTAL_TIME", CURLINFO_TOTAL_TIME); insint_c(d, "NAMELOOKUP_TIME", CURLINFO_NAMELOOKUP_TIME); insint_c(d, "CONNECT_TIME", CURLINFO_CONNECT_TIME); insint_c(d, "APPCONNECT_TIME", CURLINFO_APPCONNECT_TIME); insint_c(d, "PRETRANSFER_TIME", CURLINFO_PRETRANSFER_TIME); insint_c(d, "SIZE_UPLOAD", CURLINFO_SIZE_UPLOAD); insint_c(d, "SIZE_DOWNLOAD", CURLINFO_SIZE_DOWNLOAD); insint_c(d, "SPEED_DOWNLOAD", CURLINFO_SPEED_DOWNLOAD); insint_c(d, "SPEED_UPLOAD", CURLINFO_SPEED_UPLOAD); insint_c(d, "HEADER_SIZE", CURLINFO_HEADER_SIZE); insint_c(d, "REQUEST_SIZE", CURLINFO_REQUEST_SIZE); insint_c(d, "SSL_VERIFYRESULT", CURLINFO_SSL_VERIFYRESULT); insint_c(d, "INFO_FILETIME", CURLINFO_FILETIME); insint_c(d, "CONTENT_LENGTH_DOWNLOAD", CURLINFO_CONTENT_LENGTH_DOWNLOAD); insint_c(d, "CONTENT_LENGTH_UPLOAD", CURLINFO_CONTENT_LENGTH_UPLOAD); insint_c(d, "STARTTRANSFER_TIME", CURLINFO_STARTTRANSFER_TIME); insint_c(d, "CONTENT_TYPE", CURLINFO_CONTENT_TYPE); insint_c(d, "REDIRECT_TIME", CURLINFO_REDIRECT_TIME); insint_c(d, "REDIRECT_COUNT", CURLINFO_REDIRECT_COUNT); insint_c(d, "REDIRECT_URL", CURLINFO_REDIRECT_URL); insint_c(d, "PRIMARY_IP", CURLINFO_PRIMARY_IP); #ifdef HAVE_CURLINFO_PRIMARY_PORT insint_c(d, "PRIMARY_PORT", CURLINFO_PRIMARY_PORT); #endif #ifdef HAVE_CURLINFO_LOCAL_IP insint_c(d, "LOCAL_IP", CURLINFO_LOCAL_IP); #endif #ifdef HAVE_CURLINFO_LOCAL_PORT insint_c(d, "LOCAL_PORT", CURLINFO_LOCAL_PORT); #endif insint_c(d, "HTTP_CONNECTCODE", CURLINFO_HTTP_CONNECTCODE); insint_c(d, "HTTPAUTH_AVAIL", CURLINFO_HTTPAUTH_AVAIL); insint_c(d, "PROXYAUTH_AVAIL", CURLINFO_PROXYAUTH_AVAIL); insint_c(d, "OS_ERRNO", CURLINFO_OS_ERRNO); insint_c(d, "NUM_CONNECTS", CURLINFO_NUM_CONNECTS); insint_c(d, "SSL_ENGINES", CURLINFO_SSL_ENGINES); insint_c(d, "INFO_COOKIELIST", CURLINFO_COOKIELIST); insint_c(d, "LASTSOCKET", CURLINFO_LASTSOCKET); insint_c(d, "FTP_ENTRY_PATH", CURLINFO_FTP_ENTRY_PATH); #ifdef HAVE_CURLOPT_CERTINFO insint_c(d, "INFO_CERTINFO", CURLINFO_CERTINFO); #endif #ifdef HAVE_CURL_7_19_4_OPTS insint_c(d, "CONDITION_UNMET", CURLINFO_CONDITION_UNMET); #endif /* CURLPAUSE: symbolic constants for pause(bitmask) */ insint_c(d, "PAUSE_RECV", CURLPAUSE_RECV); insint_c(d, "PAUSE_SEND", CURLPAUSE_SEND); insint_c(d, "PAUSE_ALL", CURLPAUSE_ALL); insint_c(d, "PAUSE_CONT", CURLPAUSE_CONT); #ifdef HAVE_CURL_7_19_5_OPTS /* CURL_SEEKFUNC: return values for seek function */ insint_c(d, "SEEKFUNC_OK", CURL_SEEKFUNC_OK); insint_c(d, "SEEKFUNC_FAIL", CURL_SEEKFUNC_FAIL); insint_c(d, "SEEKFUNC_CANTSEEK", CURL_SEEKFUNC_CANTSEEK); #endif #ifdef HAVE_CURLOPT_DNS_SERVERS insint_c(d, "DNS_SERVERS", CURLOPT_DNS_SERVERS); #endif #ifdef HAVE_CURLOPT_POSTREDIR insint_c(d, "REDIR_POST_301", CURL_REDIR_POST_301); insint_c(d, "REDIR_POST_302", CURL_REDIR_POST_302); # ifdef HAVE_CURL_REDIR_POST_303 insint_c(d, "REDIR_POST_303", CURL_REDIR_POST_303); # endif insint_c(d, "REDIR_POST_ALL", CURL_REDIR_POST_ALL); #endif /* options for global_init() */ insint(d, "GLOBAL_SSL", CURL_GLOBAL_SSL); insint(d, "GLOBAL_WIN32", CURL_GLOBAL_WIN32); insint(d, "GLOBAL_ALL", CURL_GLOBAL_ALL); insint(d, "GLOBAL_NOTHING", CURL_GLOBAL_NOTHING); insint(d, "GLOBAL_DEFAULT", CURL_GLOBAL_DEFAULT); #ifdef CURL_GLOBAL_ACK_EINTR /* CURL_GLOBAL_ACK_EINTR was introduced in libcurl-7.30.0 */ insint(d, "GLOBAL_ACK_EINTR", CURL_GLOBAL_ACK_EINTR); #endif /* constants for curl_multi_socket interface */ insint(d, "CSELECT_IN", CURL_CSELECT_IN); insint(d, "CSELECT_OUT", CURL_CSELECT_OUT); insint(d, "CSELECT_ERR", CURL_CSELECT_ERR); insint(d, "SOCKET_TIMEOUT", CURL_SOCKET_TIMEOUT); insint(d, "POLL_NONE", CURL_POLL_NONE); insint(d, "POLL_IN", CURL_POLL_IN); insint(d, "POLL_OUT", CURL_POLL_OUT); insint(d, "POLL_INOUT", CURL_POLL_INOUT); insint(d, "POLL_REMOVE", CURL_POLL_REMOVE); /* curl_lock_data: XXX do we need this in pycurl ??? */ /* curl_lock_access: XXX do we need this in pycurl ??? */ /* CURLSHcode: XXX do we need this in pycurl ??? */ /* CURLSHoption: XXX do we need this in pycurl ??? */ /* CURLversion: constants for curl_version_info(x) */ #if 0 /* XXX - do we need these ?? */ insint(d, "VERSION_FIRST", CURLVERSION_FIRST); insint(d, "VERSION_SECOND", CURLVERSION_SECOND); insint(d, "VERSION_THIRD", CURLVERSION_THIRD); insint(d, "VERSION_NOW", CURLVERSION_NOW); #endif /* version features - bitmasks for curl_version_info_data.features */ #if 0 /* XXX - do we need these ?? */ /* XXX - should we really rename these ?? */ insint(d, "VERSION_FEATURE_IPV6", CURL_VERSION_IPV6); insint(d, "VERSION_FEATURE_KERBEROS4", CURL_VERSION_KERBEROS4); insint(d, "VERSION_FEATURE_SSL", CURL_VERSION_SSL); insint(d, "VERSION_FEATURE_LIBZ", CURL_VERSION_LIBZ); insint(d, "VERSION_FEATURE_NTLM", CURL_VERSION_NTLM); insint(d, "VERSION_FEATURE_GSSNEGOTIATE", CURL_VERSION_GSSNEGOTIATE); insint(d, "VERSION_FEATURE_DEBUG", CURL_VERSION_DEBUG); insint(d, "VERSION_FEATURE_ASYNCHDNS", CURL_VERSION_ASYNCHDNS); insint(d, "VERSION_FEATURE_SPNEGO", CURL_VERSION_SPNEGO); insint(d, "VERSION_FEATURE_LARGEFILE", CURL_VERSION_LARGEFILE); insint(d, "VERSION_FEATURE_IDN", CURL_VERSION_IDN); #endif /** ** the order of these constants mostly follows <curl/multi.h> **/ /* CURLMcode: multi error codes */ curlmultiobject_constants = PyDict_New(); assert(curlmultiobject_constants != NULL); insint_m(d, "E_CALL_MULTI_PERFORM", CURLM_CALL_MULTI_PERFORM); insint_m(d, "E_MULTI_OK", CURLM_OK); insint_m(d, "E_MULTI_BAD_HANDLE", CURLM_BAD_HANDLE); insint_m(d, "E_MULTI_BAD_EASY_HANDLE", CURLM_BAD_EASY_HANDLE); insint_m(d, "E_MULTI_OUT_OF_MEMORY", CURLM_OUT_OF_MEMORY); insint_m(d, "E_MULTI_INTERNAL_ERROR", CURLM_INTERNAL_ERROR); /* curl shared constants */ curlshareobject_constants = PyDict_New(); assert(curlshareobject_constants != NULL); insint_s(d, "SH_SHARE", CURLSHOPT_SHARE); insint_s(d, "SH_UNSHARE", CURLSHOPT_UNSHARE); insint_s(d, "LOCK_DATA_COOKIE", CURL_LOCK_DATA_COOKIE); insint_s(d, "LOCK_DATA_DNS", CURL_LOCK_DATA_DNS); insint_s(d, "LOCK_DATA_SSL_SESSION", CURL_LOCK_DATA_SSL_SESSION); /* Initialize callback locks if ssl is enabled */ #if defined(PYCURL_NEED_SSL_TSL) pycurl_ssl_init(); #endif #ifdef WITH_THREAD /* Finally initialize global interpreter lock */ PyEval_InitThreads(); #endif #if PY_MAJOR_VERSION >= 3 return m; #endif }
void init_rpm(void) { PyObject * d, * o, * m; #if Py_TPFLAGS_HAVE_ITER /* XXX backport to python-1.5.2 */ if (PyType_Ready(&hdr_Type) < 0) return; if (PyType_Ready(&rpmal_Type) < 0) return; if (PyType_Ready(&rpmds_Type) < 0) return; if (PyType_Ready(&rpmfd_Type) < 0) return; if (PyType_Ready(&rpmfts_Type) < 0) return; if (PyType_Ready(&rpmfi_Type) < 0) return; if (PyType_Ready(&rpmmi_Type) < 0) return; if (PyType_Ready(&rpmps_Type) < 0) return; if (PyType_Ready(&rpmtd_Type) < 0) return; if (PyType_Ready(&rpmKeyring_Type) < 0) return; if (PyType_Ready(&rpmPubkey_Type) < 0) return; if (PyType_Ready(&rpmte_Type) < 0) return; if (PyType_Ready(&rpmts_Type) < 0) return; if (PyType_Ready(&spec_Type) < 0) return; #endif m = Py_InitModule3("_rpm", rpmModuleMethods, rpm__doc__); if (m == NULL) return; /* * treat error to register rpm cleanup hook as fatal, tracebacks * can and will leave stale locks around if we can't clean up */ if (Py_AtExit(rpm_exithook) == -1) return; rpmReadConfigFiles(NULL, NULL); d = PyModule_GetDict(m); #ifdef HACK pyrpmError = PyString_FromString("_rpm.error"); PyDict_SetItemString(d, "error", pyrpmError); Py_XDECREF(pyrpmError); #else pyrpmError = PyErr_NewException("_rpm.error", NULL, NULL); if (pyrpmError != NULL) PyDict_SetItemString(d, "error", pyrpmError); #endif #if Py_TPFLAGS_HAVE_ITER /* XXX backport to python-1.5.2 */ Py_INCREF(&hdr_Type); PyModule_AddObject(m, "hdr", (PyObject *) &hdr_Type); Py_INCREF(&rpmal_Type); PyModule_AddObject(m, "al", (PyObject *) &rpmal_Type); Py_INCREF(&rpmds_Type); PyModule_AddObject(m, "ds", (PyObject *) &rpmds_Type); Py_INCREF(&rpmfd_Type); PyModule_AddObject(m, "fd", (PyObject *) &rpmfd_Type); Py_INCREF(&rpmfts_Type); PyModule_AddObject(m, "fts", (PyObject *) &rpmfts_Type); Py_INCREF(&rpmfi_Type); PyModule_AddObject(m, "fi", (PyObject *) &rpmfi_Type); Py_INCREF(&rpmKeyring_Type); PyModule_AddObject(m, "Keyring", (PyObject *) &rpmKeyring_Type); Py_INCREF(&rpmPubkey_Type); PyModule_AddObject(m, "Pubkey", (PyObject *) &rpmPubkey_Type); Py_INCREF(&rpmmi_Type); PyModule_AddObject(m, "mi", (PyObject *) &rpmmi_Type); Py_INCREF(&rpmps_Type); PyModule_AddObject(m, "ps", (PyObject *) &rpmps_Type); Py_INCREF(&rpmtd_Type); PyModule_AddObject(m, "td", (PyObject *) &rpmtd_Type); Py_INCREF(&rpmte_Type); PyModule_AddObject(m, "te", (PyObject *) &rpmte_Type); Py_INCREF(&rpmts_Type); PyModule_AddObject(m, "ts", (PyObject *) &rpmts_Type); Py_INCREF(&spec_Type); PyModule_AddObject(m, "spec", (PyObject *) &spec_Type); #else hdr_Type.ob_type = &PyType_Type; rpmal_Type.ob_type = &PyType_Type; rpmds_Type.ob_type = &PyType_Type; rpmfd_Type.ob_type = &PyType_Type; rpmfts_Type.ob_type = &PyType_Type; rpmfi_Type.ob_type = &PyType_Type; rpmmi_Type.ob_type = &PyType_Type; rpmps_Type.ob_type = &PyType_Type; rpmte_Type.ob_type = &PyType_Type; rpmts_Type.ob_type = &PyType_Type; spec_Type.ob_type = &PyType_Type; #endif addRpmTags(m); #define REGISTER_ENUM(val) \ PyDict_SetItemString(d, #val, o=PyInt_FromLong( val )); \ Py_XDECREF(o); REGISTER_ENUM(RPMFILE_STATE_NORMAL); REGISTER_ENUM(RPMFILE_STATE_REPLACED); REGISTER_ENUM(RPMFILE_STATE_NOTINSTALLED); REGISTER_ENUM(RPMFILE_STATE_NETSHARED); REGISTER_ENUM(RPMFILE_STATE_WRONGCOLOR); REGISTER_ENUM(RPMFILE_CONFIG); REGISTER_ENUM(RPMFILE_DOC); REGISTER_ENUM(RPMFILE_ICON); REGISTER_ENUM(RPMFILE_MISSINGOK); REGISTER_ENUM(RPMFILE_NOREPLACE); REGISTER_ENUM(RPMFILE_GHOST); REGISTER_ENUM(RPMFILE_LICENSE); REGISTER_ENUM(RPMFILE_README); REGISTER_ENUM(RPMFILE_EXCLUDE); REGISTER_ENUM(RPMFILE_UNPATCHED); REGISTER_ENUM(RPMFILE_PUBKEY); REGISTER_ENUM(RPMDEP_SENSE_REQUIRES); REGISTER_ENUM(RPMDEP_SENSE_CONFLICTS); REGISTER_ENUM(RPMSENSE_LESS); REGISTER_ENUM(RPMSENSE_GREATER); REGISTER_ENUM(RPMSENSE_EQUAL); REGISTER_ENUM(RPMSENSE_NOTEQUAL); REGISTER_ENUM(RPMSENSE_FIND_REQUIRES); #if defined(RPM_VENDOR_MANDRIVA) REGISTER_ENUM(RPMSENSE_PREREQ); REGISTER_ENUM(RPMSENSE_SCRIPT_PRE); REGISTER_ENUM(RPMSENSE_SCRIPT_POST); REGISTER_ENUM(RPMSENSE_SCRIPT_PREUN); REGISTER_ENUM(RPMSENSE_SCRIPT_POSTUN) #endif REGISTER_ENUM(RPMDEPS_FLAG_NOUPGRADE); REGISTER_ENUM(RPMDEPS_FLAG_NOREQUIRES); REGISTER_ENUM(RPMDEPS_FLAG_NOCONFLICTS); REGISTER_ENUM(RPMDEPS_FLAG_NOOBSOLETES); REGISTER_ENUM(RPMDEPS_FLAG_NOPARENTDIRS); REGISTER_ENUM(RPMDEPS_FLAG_NOLINKTOS); REGISTER_ENUM(RPMDEPS_FLAG_ANACONDA); REGISTER_ENUM(RPMDEPS_FLAG_NOSUGGEST); REGISTER_ENUM(RPMDEPS_FLAG_ADDINDEPS); REGISTER_ENUM(RPMDEPS_FLAG_DEPLOOPS); REGISTER_ENUM(RPMTRANS_FLAG_TEST); REGISTER_ENUM(RPMTRANS_FLAG_BUILD_PROBS); REGISTER_ENUM(RPMTRANS_FLAG_NOSCRIPTS); REGISTER_ENUM(RPMTRANS_FLAG_JUSTDB); REGISTER_ENUM(RPMTRANS_FLAG_NOTRIGGERS); REGISTER_ENUM(RPMTRANS_FLAG_NODOCS); REGISTER_ENUM(RPMTRANS_FLAG_ALLFILES); REGISTER_ENUM(RPMTRANS_FLAG_NORPMDB); REGISTER_ENUM(RPMTRANS_FLAG_REPACKAGE); REGISTER_ENUM(RPMTRANS_FLAG_NOPRE); REGISTER_ENUM(RPMTRANS_FLAG_NOPOST); REGISTER_ENUM(RPMTRANS_FLAG_NOTRIGGERPREIN); REGISTER_ENUM(RPMTRANS_FLAG_NOTRIGGERIN); REGISTER_ENUM(RPMTRANS_FLAG_NOTRIGGERUN); REGISTER_ENUM(RPMTRANS_FLAG_NOPREUN); REGISTER_ENUM(RPMTRANS_FLAG_NOPOSTUN); REGISTER_ENUM(RPMTRANS_FLAG_NOTRIGGERPOSTUN); REGISTER_ENUM(RPMTRANS_FLAG_NOFDIGESTS); REGISTER_ENUM(RPMTRANS_FLAG_NOCONFIGS); REGISTER_ENUM(RPMPROB_FILTER_IGNOREOS); REGISTER_ENUM(RPMPROB_FILTER_IGNOREARCH); REGISTER_ENUM(RPMPROB_FILTER_REPLACEPKG); REGISTER_ENUM(RPMPROB_FILTER_FORCERELOCATE); REGISTER_ENUM(RPMPROB_FILTER_REPLACENEWFILES); REGISTER_ENUM(RPMPROB_FILTER_REPLACEOLDFILES); REGISTER_ENUM(RPMPROB_FILTER_OLDPACKAGE); REGISTER_ENUM(RPMPROB_FILTER_DISKSPACE); REGISTER_ENUM(RPMPROB_FILTER_DISKNODES); REGISTER_ENUM(RPMCALLBACK_UNKNOWN); REGISTER_ENUM(RPMCALLBACK_INST_PROGRESS); REGISTER_ENUM(RPMCALLBACK_INST_START); REGISTER_ENUM(RPMCALLBACK_INST_OPEN_FILE); REGISTER_ENUM(RPMCALLBACK_INST_CLOSE_FILE); REGISTER_ENUM(RPMCALLBACK_TRANS_PROGRESS); REGISTER_ENUM(RPMCALLBACK_TRANS_START); REGISTER_ENUM(RPMCALLBACK_TRANS_STOP); REGISTER_ENUM(RPMCALLBACK_UNINST_PROGRESS); REGISTER_ENUM(RPMCALLBACK_UNINST_START); REGISTER_ENUM(RPMCALLBACK_UNINST_STOP); REGISTER_ENUM(RPMCALLBACK_REPACKAGE_PROGRESS); REGISTER_ENUM(RPMCALLBACK_REPACKAGE_START); REGISTER_ENUM(RPMCALLBACK_REPACKAGE_STOP); REGISTER_ENUM(RPMCALLBACK_UNPACK_ERROR); REGISTER_ENUM(RPMCALLBACK_CPIO_ERROR); REGISTER_ENUM(RPMCALLBACK_SCRIPT_ERROR); REGISTER_ENUM(RPMPROB_BADARCH); REGISTER_ENUM(RPMPROB_BADOS); REGISTER_ENUM(RPMPROB_PKG_INSTALLED); REGISTER_ENUM(RPMPROB_BADRELOCATE); REGISTER_ENUM(RPMPROB_REQUIRES); REGISTER_ENUM(RPMPROB_CONFLICT); REGISTER_ENUM(RPMPROB_NEW_FILE_CONFLICT); REGISTER_ENUM(RPMPROB_FILE_CONFLICT); REGISTER_ENUM(RPMPROB_OLDPACKAGE); REGISTER_ENUM(RPMPROB_DISKSPACE); REGISTER_ENUM(RPMPROB_DISKNODES); REGISTER_ENUM(RPMPROB_BADPRETRANS); REGISTER_ENUM(VERIFY_DIGEST); REGISTER_ENUM(VERIFY_SIGNATURE); REGISTER_ENUM(RPMLOG_EMERG); REGISTER_ENUM(RPMLOG_ALERT); REGISTER_ENUM(RPMLOG_CRIT); REGISTER_ENUM(RPMLOG_ERR); REGISTER_ENUM(RPMLOG_WARNING); REGISTER_ENUM(RPMLOG_NOTICE); REGISTER_ENUM(RPMLOG_INFO); REGISTER_ENUM(RPMLOG_DEBUG); REGISTER_ENUM(RPMMIRE_DEFAULT); REGISTER_ENUM(RPMMIRE_STRCMP); REGISTER_ENUM(RPMMIRE_REGEX); REGISTER_ENUM(RPMMIRE_GLOB); REGISTER_ENUM(RPMVSF_DEFAULT); REGISTER_ENUM(RPMVSF_NOHDRCHK); REGISTER_ENUM(RPMVSF_NEEDPAYLOAD); REGISTER_ENUM(RPMVSF_NOSHA1HEADER); REGISTER_ENUM(RPMVSF_NOMD5HEADER); REGISTER_ENUM(RPMVSF_NODSAHEADER); REGISTER_ENUM(RPMVSF_NORSAHEADER); REGISTER_ENUM(RPMVSF_NOSHA1); REGISTER_ENUM(RPMVSF_NOMD5); REGISTER_ENUM(RPMVSF_NODSA); REGISTER_ENUM(RPMVSF_NORSA); REGISTER_ENUM(_RPMVSF_NODIGESTS); REGISTER_ENUM(_RPMVSF_NOSIGNATURES); REGISTER_ENUM(_RPMVSF_NOHEADER); REGISTER_ENUM(_RPMVSF_NOPAYLOAD); REGISTER_ENUM(TR_ADDED); REGISTER_ENUM(TR_REMOVED); REGISTER_ENUM(RPMDBI_PACKAGES); REGISTER_ENUM((long)RPMAL_NOMATCH); }
PyMODINIT_FUNC initttconv(void) { Py_InitModule3("ttconv", ttconv_methods, module_docstring); }
PyMODINIT_FUNC inithello(void) { Py_InitModule3("hello", helloMethods, module_docstring); }