/* initialization of the module */
PyMODINIT_FUNC initctemplate (void) {
PyObject* m;
if (PyType_Ready(&Template_Type) < 0) {
return;
}
if (PyType_Ready(&Dictionary_Type) < 0) {
return;
}
m = Py_InitModule3("ctemplate", ctemplate_methods,
"Wrapper for the ctemplate library.");
if (m == NULL) {
goto onError;
}
/* Register cleanup function */
if (Py_AtExit(ctemplate_Cleanup) == -1)
goto onError;
Py_INCREF(&Template_Type);
if (PyModule_AddObject(m, "Template",
(PyObject *)&Template_Type) == -1) {
goto onError;
}
Py_INCREF(&Dictionary_Type);
if (PyModule_AddObject(m, "Dictionary",
(PyObject *)&Dictionary_Type) == -1) {
goto onError;
}
add_constants(m);
onError:
if (PyErr_Occurred())
Py_ReportModuleInitError("ctemplate");
}
void
initrufl(void)
{
PyObject *module;
rufl_code code;
code = rufl_init();
if (code != rufl_OK)
Py_FatalError("rufl_init() failed");
Py_AtExit(rufl_quit);
/* Create the module and add the functions */
module = Py_InitModule4("rufl", pyrufl_methods,
pyrufl_module_documentation,
(PyObject *) NULL, PYTHON_API_VERSION);
/* Add some symbolic constants to the module */
PyModule_AddIntConstant(module, "regular", rufl_REGULAR);
PyModule_AddIntConstant(module, "slanted", rufl_SLANTED);
PyModule_AddIntConstant(module, "bold", rufl_BOLD);
PyModule_AddIntConstant(module, "bold_slanted", rufl_BOLD_SLANTED);
PyModule_AddIntConstant(module, "blend", rufl_BLEND_FONT);
/* Check for errors */
if (PyErr_Occurred())
Py_FatalError("can't initialize module rufl");
}
PyMODINIT_FUNC
PyInit_simplepinyin(void)
{
context = pinyin_init(LIBPINYIN_DATA, "/tmp");
// printf("DEBUG: pinyin_init\n");
if (context == NULL)
return NULL;
pinyin_option_t options =
PINYIN_CORRECT_ALL | USE_DIVIDED_TABLE | USE_RESPLIT_TABLE |
0;
if (!pinyin_set_options(context, options))
return NULL;
if (Py_AtExit(libpinyin_cleanup) == -1)
return NULL;
PyObject* m;
if (PyType_Ready(&SimplePinyinType) < 0)
return NULL;
m = PyModule_Create(&simplepinyinmodule);
if (m == NULL)
return NULL;
Py_INCREF(&SimplePinyinType);
PyModule_AddObject(m, "SimplePinyin", (PyObject *)&SimplePinyinType);
return m;
}
void initsps()
#endif
{
struct module_state *st;
PyObject *d;
//printf("Initializing sps\n");
/* Add some symbolic constants to the module */
#if PY_MAJOR_VERSION >= 3
PyObject *module = PyModule_Create(&moduledef);
#else
PyObject *module = Py_InitModule("sps", SPSMethods);
#endif
d = PyModule_GetDict(module);
if (module == NULL)
INITERROR;
st = GETSTATE(module);
PyDict_SetItemString(d, "DOUBLE", (PyObject *) PyInt_FromLong(SPS_DOUBLE));
PyDict_SetItemString(d, "FLOAT", (PyObject *) PyInt_FromLong(SPS_FLOAT));
PyDict_SetItemString(d, "INT", (PyObject *) PyInt_FromLong(SPS_INT));
PyDict_SetItemString(d, "UINT", (PyObject *) PyInt_FromLong(SPS_UINT));
PyDict_SetItemString(d, "SHORT", (PyObject *) PyInt_FromLong(SPS_SHORT));
PyDict_SetItemString(d, "USHORT", (PyObject *) PyInt_FromLong(SPS_USHORT));
PyDict_SetItemString(d, "CHAR", (PyObject *) PyInt_FromLong(SPS_CHAR));
PyDict_SetItemString(d, "UCHAR", (PyObject *) PyInt_FromLong(SPS_UCHAR));
PyDict_SetItemString(d, "STRING", (PyObject *) PyInt_FromLong(SPS_STRING));
PyDict_SetItemString(d, "IS_ARRAY", (PyObject *) PyInt_FromLong(SPS_IS_ARRAY));
PyDict_SetItemString(d, "IS_MCA", (PyObject *) PyInt_FromLong(SPS_IS_MCA));
PyDict_SetItemString(d, "IS_IMAGE", (PyObject *) PyInt_FromLong(SPS_IS_IMAGE));
PyDict_SetItemString(d, "TAG_STATUS", (PyObject *) PyInt_FromLong(SPS_TAG_STATUS));
PyDict_SetItemString(d, "TAG_ARRAY", (PyObject *) PyInt_FromLong(SPS_TAG_ARRAY));
PyDict_SetItemString(d, "TAG_MASK", (PyObject *) PyInt_FromLong(SPS_TAG_MASK));
PyDict_SetItemString(d, "TAG_MCA", (PyObject *) PyInt_FromLong(SPS_TAG_MCA));
PyDict_SetItemString(d, "TAG_IMAGE", (PyObject *) PyInt_FromLong(SPS_TAG_IMAGE));
PyDict_SetItemString(d, "TAG_SCAN", (PyObject *) PyInt_FromLong(SPS_TAG_SCAN));
PyDict_SetItemString(d, "TAG_INFO", (PyObject *) PyInt_FromLong(SPS_TAG_INFO));
PyDict_SetItemString(d, "TAG_FRAMES", (PyObject *) PyInt_FromLong(SPS_TAG_FRAMES));
st->SPSError = PyErr_NewException("sps.error", NULL, NULL);
if (st->SPSError == NULL) {
Py_DECREF(module);
INITERROR;
}
Py_INCREF(st->SPSError);
PyModule_AddObject(module, "error", st->SPSError);
Py_AtExit(sps_cleanup);
import_array();
#if PY_MAJOR_VERSION >= 3
return module;
#endif
}
PyMODINIT_FUNC
PyInit_logging_test(void)
{
// stock...
PyObject * m;
m = PyModule_Create(&module);
if (m == NULL)
return NULL;
// ... end of stock
//logging = logging_config("logging", module.m_name, "C");
logging = logging_basicConfig();
Py_AtExit(kill_PythonLogging); // Can call multiple times, exit_logging should be called first
example();
return m;
}
PyMODINIT_FUNC
initgtop(void)
{
PyObject* module;
glibtop_init();
Py_AtExit(gtop_at_exit);
module = Py_InitModule("gtop", (PyMethodDef*) gtop_methods);
PyType_Ready((PyTypeObject*) &StructType);
PyObject_SetAttrString(module, "_Struct", (void*) &StructType);
register_constants(module);
PyModule_AddObject(module, "siglist", build_siglist());
}
initfaulthandler(void)
#endif
{
PyObject *m, *version;
#if PY_MAJOR_VERSION >= 3
m = PyModule_Create(&module_def);
#else
m = Py_InitModule3("faulthandler", module_methods, module_doc);
#endif
if (m == NULL) {
#if PY_MAJOR_VERSION >= 3
return NULL;
#else
return;
#endif
}
#ifdef HAVE_SIGALTSTACK
/* Try to allocate an alternate stack for faulthandler() signal handler to
* be able to allocate memory on the stack, even on a stack overflow. If it
* fails, ignore the error. */
faulthandler_stack.ss_flags = SS_ONSTACK;
faulthandler_stack.ss_size = SIGSTKSZ;
faulthandler_stack.ss_sp = PyMem_Malloc(faulthandler_stack.ss_size);
if (faulthandler_stack.ss_sp != NULL) {
(void)sigaltstack(&faulthandler_stack, NULL);
}
#endif
(void)Py_AtExit(faulthandler_unload);
#if PY_MAJOR_VERSION >= 3
version = PyLong_FromLong(VERSION);
#else
version = PyInt_FromLong(VERSION);
#endif
PyModule_AddObject(m, "version", version);
#if PY_MAJOR_VERSION >= 3
return m;
#endif
}
PyMODINIT_FUNC initlibre(void)
{
PyObject *m;
int err;
Py_AtExit(exit_handler);
/* Initialize libre */
err = libre_init();
if (err) {
re_fprintf(stderr, "could not initialize libre: %s\n",
strerror(err));
return;
}
m = pylibre_initmain();
pylibre_initerror(m);
pylibre_initsip(m);
pylibre_inituri(m);
}
PyMODINIT_FUNC init_pongo(void)
{
PyObject *m;
PyObject *uumod;
PyDateTime_IMPORT;
m = Py_InitModule("_pongo", _pongo_methods);
PyType_Ready(&PongoList_Type);
PyType_Ready(&PongoDict_Type);
PyType_Ready(&PongoCollection_Type);
PyType_Ready(&PongoPointer_Type);
PyType_Ready(&PongoIter_Type);
Py_INCREF(&PongoList_Type);
Py_INCREF(&PongoDict_Type);
Py_INCREF(&PongoCollection_Type);
Py_INCREF(&PongoPointer_Type);
Py_INCREF(&PongoIter_Type);
PyModule_AddObject(m, "PongoList", (PyObject*)&PongoList_Type);
PyModule_AddObject(m, "PongoDict", (PyObject*)&PongoDict_Type);
PyModule_AddObject(m, "PongoCollection", (PyObject*)&PongoCollection_Type);
PyModule_AddObject(m, "PongoPointer", (PyObject*)&PongoPointer_Type);
PyModule_AddObject(m, "PongoIter", (PyObject*)&PongoIter_Type);
pongo_id = PyObject_CallFunction((PyObject*)&PyBaseObject_Type, NULL);
PyModule_AddObject(m, "id", pongo_id);
pongo_utcnow = PyObject_CallFunction((PyObject*)&PyBaseObject_Type, NULL);
PyModule_AddObject(m, "utcnow", pongo_utcnow);
#ifdef WANT_UUID_TYPE
uumod = PyImport_ImportModule("uuid");
uuid_constructor = PyObject_GetAttrString(uumod, "UUID");
uuid_class = (PyTypeObject*)uuid_constructor;
#endif
Py_AtExit(pongo_atexit);
log_init(NULL, LOG_DEBUG);
}
void initsps()
{
PyObject *d, *m;
m = Py_InitModule ("sps", SPSMethods);
//printf("Initializing sps\n");
/* Add some symbolic constants to the module */
d = PyModule_GetDict(m);
PyDict_SetItemString(d, "DOUBLE", PyInt_FromLong(SPS_DOUBLE));
PyDict_SetItemString(d, "FLOAT", PyInt_FromLong(SPS_FLOAT));
PyDict_SetItemString(d, "INT", PyInt_FromLong(SPS_INT));
PyDict_SetItemString(d, "UINT", PyInt_FromLong(SPS_UINT));
PyDict_SetItemString(d, "SHORT", PyInt_FromLong(SPS_SHORT));
PyDict_SetItemString(d, "USHORT", PyInt_FromLong(SPS_USHORT));
PyDict_SetItemString(d, "CHAR", PyInt_FromLong(SPS_CHAR));
PyDict_SetItemString(d, "UCHAR", PyInt_FromLong(SPS_UCHAR));
PyDict_SetItemString(d, "STRING", PyInt_FromLong(SPS_STRING));
PyDict_SetItemString(d, "IS_ARRAY", PyInt_FromLong(SPS_IS_ARRAY));
PyDict_SetItemString(d, "IS_MCA", PyInt_FromLong(SPS_IS_MCA));
PyDict_SetItemString(d, "IS_IMAGE", PyInt_FromLong(SPS_IS_IMAGE));
PyDict_SetItemString(d, "TAG_STATUS", PyInt_FromLong(SPS_TAG_STATUS));
PyDict_SetItemString(d, "TAG_ARRAY", PyInt_FromLong(SPS_TAG_ARRAY));
PyDict_SetItemString(d, "TAG_MASK", PyInt_FromLong(SPS_TAG_MASK));
PyDict_SetItemString(d, "TAG_MCA", PyInt_FromLong(SPS_TAG_MCA));
PyDict_SetItemString(d, "TAG_IMAGE", PyInt_FromLong(SPS_TAG_IMAGE));
PyDict_SetItemString(d, "TAG_SCAN", PyInt_FromLong(SPS_TAG_SCAN));
PyDict_SetItemString(d, "TAG_INFO", PyInt_FromLong(SPS_TAG_INFO));
PyDict_SetItemString(d, "TAG_FRAMES", PyInt_FromLong(SPS_TAG_FRAMES));
SPSError = PyErr_NewException("sps.error", NULL, NULL);
PyDict_SetItemString(d, "error", SPSError);
Py_AtExit(sps_cleanup);
import_array();
}
/**
* python-krb5 initialization function.
*/
PyMODINIT_FUNC initkrb5(void)
{
PyObject *module;
krb5_error_code rc;
if(PyType_Ready(&PrincipalType) < 0)
return;
if(PyType_Ready(&CredentialType) < 0)
return;
module = Py_InitModule("krb5", krb5_methods);
if(module == NULL)
return;
/* define Krb5Error exception */
//Krb5Error = PyErr_NewException("krb5.Krb5Error", NULL, NULL);
//Py_INCREF(Krb5Error);
//PyModule_AddObject(module, "error", Krb5Error);
/* initialize kerberos */
rc = krb5_init_context(&module_context);
if(rc) {
return;
}
/* Add the Principal object */
Py_INCREF(&PrincipalType);
PyModule_AddObject(module, "Principal", (PyObject *)&PrincipalType);
/* Add the Credential object */
Py_INCREF(&CredentialType);
PyModule_AddObject(module, "Credential", (PyObject *)&CredentialType);
/* define module cleanup function */
Py_AtExit(cleanup);
}
PyMODINIT_FUNC init_PWM(void)
#endif
{
PyObject *module = NULL;
#if PY_MAJOR_VERSION > 2
if ((module = PyModule_Create(&pwmmodule)) == NULL)
return module;
#else
if ((module = Py_InitModule("_PWM", pwm_methods)) == NULL)
return;
#endif
PyModule_AddObject(module, "VERSION", Py_BuildValue("s", "0.9.6"));
PyModule_AddObject(module, "DELAY_VIA_PWM", Py_BuildValue("i", DELAY_VIA_PWM));
PyModule_AddObject(module, "DELAY_VIA_PCM", Py_BuildValue("i", DELAY_VIA_PCM));
PyModule_AddObject(module, "LOG_LEVEL_DEBUG", Py_BuildValue("i", LOG_LEVEL_DEBUG));
PyModule_AddObject(module, "LOG_LEVEL_ERRORS", Py_BuildValue("i", LOG_LEVEL_ERRORS));
PyModule_AddObject(module, "LOG_LEVEL_DEFAULT", Py_BuildValue("i", LOG_LEVEL_DEFAULT));
PyModule_AddObject(module, "SUBCYCLE_TIME_US_DEFAULT", Py_BuildValue("i", SUBCYCLE_TIME_US_DEFAULT));
PyModule_AddObject(module, "PULSE_WIDTH_INCREMENT_GRANULARITY_US_DEFAULT", Py_BuildValue("i", PULSE_WIDTH_INCREMENT_GRANULARITY_US_DEFAULT));
// Enable PWM.C soft-fatal mode in order to convert them to python exceptions
set_softfatal(1);
// Add shutdown handler to be executed when python script stops
if (Py_AtExit(shutdown) != 0) {
shutdown();
}
#if PY_MAJOR_VERSION > 2
return module;
#else
return;
#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);
}
// Cython doesn't have Py_AtExit bindings, so we call the C_API directly
int pygrpc_initialize_core(void) {
grpc_init();
return Py_AtExit(grpc_shutdown) < 0 ? 0 : 1;
}
PyMODINIT_FUNC
initdsui_mod(void)
{
Py_InitModule("dsui_mod", DsuiMethods);
Py_AtExit(cleanup_callback);
}
PyMODINIT_FUNC init_GPIO(void)
#endif
{
PyObject *module = NULL;
#if PY_MAJOR_VERSION > 2
if ((module = PyModule_Create(&rpigpiomodule)) == NULL)
goto exit;
#else
if ((module = Py_InitModule("_GPIO", rpi_gpio_methods)) == NULL)
goto exit;
#endif
WrongDirectionException = PyErr_NewException("RPIO.Exceptions.WrongDirectionException", NULL, NULL);
PyModule_AddObject(module, "WrongDirectionException", WrongDirectionException);
InvalidModeException = PyErr_NewException("RPIO.Exceptions.InvalidModeException", NULL, NULL);
PyModule_AddObject(module, "InvalidModeException", InvalidModeException);
InvalidDirectionException = PyErr_NewException("RPIO.Exceptions.InvalidDirectionException", NULL, NULL);
PyModule_AddObject(module, "InvalidDirectionException", InvalidDirectionException);
InvalidChannelException = PyErr_NewException("RPIO.Exceptions.InvalidChannelException", NULL, NULL);
PyModule_AddObject(module, "InvalidChannelException", InvalidChannelException);
InvalidPullException = PyErr_NewException("RPIO.Exceptions.InvalidPullException", NULL, NULL);
PyModule_AddObject(module, "InvalidPullException", InvalidPullException);
ModeNotSetException = PyErr_NewException("RPIO.Exceptions.ModeNotSetException", NULL, NULL);
PyModule_AddObject(module, "ModeNotSetException", ModeNotSetException);
high = Py_BuildValue("i", HIGH);
PyModule_AddObject(module, "HIGH", high);
low = Py_BuildValue("i", LOW);
PyModule_AddObject(module, "LOW", low);
output = Py_BuildValue("i", OUTPUT);
PyModule_AddObject(module, "OUT", output);
input = Py_BuildValue("i", INPUT);
PyModule_AddObject(module, "IN", input);
alt0 = Py_BuildValue("i", ALT0);
PyModule_AddObject(module, "ALT0", alt0);
board = Py_BuildValue("i", BOARD);
PyModule_AddObject(module, "BOARD", board);
bcm = Py_BuildValue("i", BCM);
PyModule_AddObject(module, "BCM", bcm);
pud_off = Py_BuildValue("i", PUD_OFF);
PyModule_AddObject(module, "PUD_OFF", pud_off);
pud_up = Py_BuildValue("i", PUD_UP);
PyModule_AddObject(module, "PUD_UP", pud_up);
pud_down = Py_BuildValue("i", PUD_DOWN);
PyModule_AddObject(module, "PUD_DOWN", pud_down);
// detect board revision and set up accordingly
cache_rpi_revision();
if (revision_int < 1)
{
PyErr_SetString(PyExc_SystemError, "This module can only be run on a Raspberry Pi!");
#if PY_MAJOR_VERSION > 2
return NULL;
#else
return;
#endif
} else if (revision_int == 1) {
pin_to_gpio = &pin_to_gpio_rev1;
gpio_to_pin = &gpio_to_pin_rev1;
} else {
// assume revision 2
pin_to_gpio = &pin_to_gpio_rev2;
gpio_to_pin = &gpio_to_pin_rev2;
}
rpi_revision = Py_BuildValue("i", revision_int);
PyModule_AddObject(module, "RPI_REVISION", rpi_revision);
rpi_revision_hex = Py_BuildValue("s", revision_hex);
PyModule_AddObject(module, "RPI_REVISION_HEX", rpi_revision_hex);
version = Py_BuildValue("s", "0.10.1/0.4.2a");
PyModule_AddObject(module, "VERSION_GPIO", version);
// set up mmaped areas
if (module_setup() != SETUP_OK ) {
#if PY_MAJOR_VERSION > 2
return NULL;
#else
return;
#endif
}
if (Py_AtExit(cleanup) != 0) {
cleanup();
#if PY_MAJOR_VERSION > 2
return NULL;
#else
return;
#endif
}
exit:
#if PY_MAJOR_VERSION > 2
return module;
#else
return;
#endif
}
void
init_librepo(void)
#endif
{
#if PY_MAJOR_VERSION >= 3
PyObject *m = PyModule_Create(&moduledef);
#else
PyObject *m = Py_InitModule("_librepo", librepo_methods);
#endif
if (!m)
INITERROR;
struct module_state *st = GETSTATE(m);
// Exceptions
if (!init_exceptions()) {
Py_DECREF(m);
INITERROR;
}
st->error = LrErr_Exception;
PyModule_AddObject(m, "LibrepoException", LrErr_Exception);
// Objects
// _librepo.Handle
if (PyType_Ready(&Handle_Type) < 0)
INITERROR;
Py_INCREF(&Handle_Type);
PyModule_AddObject(m, "Handle", (PyObject *)&Handle_Type);
// _librepo.Result
if (PyType_Ready(&Result_Type) < 0)
INITERROR;
Py_INCREF(&Result_Type);
PyModule_AddObject(m, "Result", (PyObject *)&Result_Type);
// _librepo.PackageTarget
if (PyType_Ready(&PackageTarget_Type) < 0)
INITERROR;
Py_INCREF(&PackageTarget_Type);
PyModule_AddObject(m, "PackageTarget", (PyObject *)&PackageTarget_Type);
// Init module
Py_AtExit(exit_librepo);
// Module constants
#define PYMODULE_ADDINTCONSTANT(name) PyModule_AddIntConstant(m, #name, (name))
#define PYMODULE_ADDSTRCONSTANT(name) PyModule_AddStringConstant(m, #name, (name))
// Version
PYMODULE_ADDINTCONSTANT(LR_VERSION_MAJOR);
PYMODULE_ADDINTCONSTANT(LR_VERSION_MINOR);
PYMODULE_ADDINTCONSTANT(LR_VERSION_PATCH);
PYMODULE_ADDSTRCONSTANT(LR_VERSION);
// Handle options
PYMODULE_ADDINTCONSTANT(LRO_UPDATE);
PYMODULE_ADDINTCONSTANT(LRO_URLS);
PYMODULE_ADDINTCONSTANT(LRO_MIRRORLIST);
PYMODULE_ADDINTCONSTANT(LRO_MIRRORLISTURL);
PYMODULE_ADDINTCONSTANT(LRO_METALINKURL);
PYMODULE_ADDINTCONSTANT(LRO_LOCAL);
PYMODULE_ADDINTCONSTANT(LRO_HTTPAUTH);
PYMODULE_ADDINTCONSTANT(LRO_USERPWD);
PYMODULE_ADDINTCONSTANT(LRO_PROXY);
PYMODULE_ADDINTCONSTANT(LRO_PROXYPORT);
PYMODULE_ADDINTCONSTANT(LRO_PROXYTYPE);
PYMODULE_ADDINTCONSTANT(LRO_PROXYAUTH);
PYMODULE_ADDINTCONSTANT(LRO_PROXYUSERPWD);
PYMODULE_ADDINTCONSTANT(LRO_PROGRESSCB);
PYMODULE_ADDINTCONSTANT(LRO_PROGRESSDATA);
PYMODULE_ADDINTCONSTANT(LRO_MAXSPEED);
PYMODULE_ADDINTCONSTANT(LRO_DESTDIR);
PYMODULE_ADDINTCONSTANT(LRO_REPOTYPE);
PYMODULE_ADDINTCONSTANT(LRO_CONNECTTIMEOUT);
PYMODULE_ADDINTCONSTANT(LRO_IGNOREMISSING);
PYMODULE_ADDINTCONSTANT(LRO_INTERRUPTIBLE);
PYMODULE_ADDINTCONSTANT(LRO_USERAGENT);
PYMODULE_ADDINTCONSTANT(LRO_FETCHMIRRORS);
PYMODULE_ADDINTCONSTANT(LRO_MAXMIRRORTRIES);
PYMODULE_ADDINTCONSTANT(LRO_MAXPARALLELDOWNLOADS);
PYMODULE_ADDINTCONSTANT(LRO_MAXDOWNLOADSPERMIRROR);
PYMODULE_ADDINTCONSTANT(LRO_VARSUB);
PYMODULE_ADDINTCONSTANT(LRO_FASTESTMIRROR);
PYMODULE_ADDINTCONSTANT(LRO_FASTESTMIRRORCACHE);
PYMODULE_ADDINTCONSTANT(LRO_FASTESTMIRRORMAXAGE);
PYMODULE_ADDINTCONSTANT(LRO_FASTESTMIRRORCB);
PYMODULE_ADDINTCONSTANT(LRO_FASTESTMIRRORDATA);
PYMODULE_ADDINTCONSTANT(LRO_LOWSPEEDTIME);
PYMODULE_ADDINTCONSTANT(LRO_LOWSPEEDLIMIT);
PYMODULE_ADDINTCONSTANT(LRO_GPGCHECK);
PYMODULE_ADDINTCONSTANT(LRO_CHECKSUM);
PYMODULE_ADDINTCONSTANT(LRO_YUMDLIST);
PYMODULE_ADDINTCONSTANT(LRO_RPMMDDLIST);
PYMODULE_ADDINTCONSTANT(LRO_YUMBLIST);
PYMODULE_ADDINTCONSTANT(LRO_RPMMDBLIST);
PYMODULE_ADDINTCONSTANT(LRO_HMFCB);
PYMODULE_ADDINTCONSTANT(LRO_SSLVERIFYPEER);
PYMODULE_ADDINTCONSTANT(LRO_SSLVERIFYHOST);
PYMODULE_ADDINTCONSTANT(LRO_SSLCLIENTCERT);
PYMODULE_ADDINTCONSTANT(LRO_SSLCLIENTKEY);
PYMODULE_ADDINTCONSTANT(LRO_SSLCACERT);
PYMODULE_ADDINTCONSTANT(LRO_IPRESOLVE);
PYMODULE_ADDINTCONSTANT(LRO_ALLOWEDMIRRORFAILURES);
PYMODULE_ADDINTCONSTANT(LRO_ADAPTIVEMIRRORSORTING);
PYMODULE_ADDINTCONSTANT(LRO_GNUPGHOMEDIR);
PYMODULE_ADDINTCONSTANT(LRO_FASTESTMIRRORTIMEOUT);
PYMODULE_ADDINTCONSTANT(LRO_HTTPHEADER);
PYMODULE_ADDINTCONSTANT(LRO_OFFLINE);
PYMODULE_ADDINTCONSTANT(LRO_SENTINEL);
// Handle info options
PYMODULE_ADDINTCONSTANT(LRI_UPDATE);
PYMODULE_ADDINTCONSTANT(LRI_URLS);
PYMODULE_ADDINTCONSTANT(LRI_MIRRORLIST);
PYMODULE_ADDINTCONSTANT(LRI_MIRRORLISTURL);
PYMODULE_ADDINTCONSTANT(LRI_METALINKURL);
PYMODULE_ADDINTCONSTANT(LRI_LOCAL);
PYMODULE_ADDINTCONSTANT(LRI_PROGRESSCB);
PYMODULE_ADDINTCONSTANT(LRI_PROGRESSDATA);
PYMODULE_ADDINTCONSTANT(LRI_DESTDIR);
PYMODULE_ADDINTCONSTANT(LRI_REPOTYPE);
PYMODULE_ADDINTCONSTANT(LRI_USERAGENT);
PYMODULE_ADDINTCONSTANT(LRI_YUMDLIST);
PYMODULE_ADDINTCONSTANT(LRI_RPMMDDLIST);
PYMODULE_ADDINTCONSTANT(LRI_YUMBLIST);
PYMODULE_ADDINTCONSTANT(LRI_RPMMDBLIST);
PYMODULE_ADDINTCONSTANT(LRI_FETCHMIRRORS);
PYMODULE_ADDINTCONSTANT(LRI_MAXMIRRORTRIES);
PYMODULE_ADDINTCONSTANT(LRI_VARSUB);
PYMODULE_ADDINTCONSTANT(LRI_MIRRORS);
PYMODULE_ADDINTCONSTANT(LRI_METALINK);
PYMODULE_ADDINTCONSTANT(LRI_FASTESTMIRROR);
PYMODULE_ADDINTCONSTANT(LRI_FASTESTMIRRORCACHE);
PYMODULE_ADDINTCONSTANT(LRI_FASTESTMIRRORMAXAGE);
PYMODULE_ADDINTCONSTANT(LRI_HMFCB);
PYMODULE_ADDINTCONSTANT(LRI_SSLVERIFYPEER);
PYMODULE_ADDINTCONSTANT(LRI_SSLVERIFYHOST);
PYMODULE_ADDINTCONSTANT(LRI_SSLCLIENTCERT);
PYMODULE_ADDINTCONSTANT(LRI_SSLCLIENTKEY);
PYMODULE_ADDINTCONSTANT(LRI_SSLCACERT);
PYMODULE_ADDINTCONSTANT(LRI_IPRESOLVE);
PYMODULE_ADDINTCONSTANT(LRI_ALLOWEDMIRRORFAILURES);
PYMODULE_ADDINTCONSTANT(LRI_ADAPTIVEMIRRORSORTING);
PYMODULE_ADDINTCONSTANT(LRI_GNUPGHOMEDIR);
PYMODULE_ADDINTCONSTANT(LRI_FASTESTMIRRORTIMEOUT);
PYMODULE_ADDINTCONSTANT(LRI_HTTPHEADER);
PYMODULE_ADDINTCONSTANT(LRI_OFFLINE);
PYMODULE_ADDINTCONSTANT(LRI_LOWSPEEDTIME);
PYMODULE_ADDINTCONSTANT(LRI_LOWSPEEDLIMIT);
PYMODULE_ADDINTCONSTANT(LRI_SENTINEL);
// Check options
PYMODULE_ADDINTCONSTANT(LR_CHECK_GPG);
PYMODULE_ADDINTCONSTANT(LR_CHECK_CHECKSUM);
// Repo type
PYMODULE_ADDINTCONSTANT(LR_YUMREPO);
PYMODULE_ADDINTCONSTANT(LR_RPMMDREPO);
PYMODULE_ADDINTCONSTANT(LR_SUSEREPO);
PYMODULE_ADDINTCONSTANT(LR_DEBREPO);
// Proxy type
PYMODULE_ADDINTCONSTANT(LR_PROXY_HTTP);
PYMODULE_ADDINTCONSTANT(LR_PROXY_HTTP_1_0);
PYMODULE_ADDINTCONSTANT(LR_PROXY_SOCKS4);
PYMODULE_ADDINTCONSTANT(LR_PROXY_SOCKS5);
PYMODULE_ADDINTCONSTANT(LR_PROXY_SOCKS4A);
PYMODULE_ADDINTCONSTANT(LR_PROXY_SOCKS5_HOSTNAME);
// IpResolve type
PYMODULE_ADDINTCONSTANT(LR_IPRESOLVE_WHATEVER);
PYMODULE_ADDINTCONSTANT(LR_IPRESOLVE_V4);
PYMODULE_ADDINTCONSTANT(LR_IPRESOLVE_V6);
// Return codes
PYMODULE_ADDINTCONSTANT(LRE_OK);
PYMODULE_ADDINTCONSTANT(LRE_BADFUNCARG);
PYMODULE_ADDINTCONSTANT(LRE_BADOPTARG);
PYMODULE_ADDINTCONSTANT(LRE_UNKNOWNOPT);
PYMODULE_ADDINTCONSTANT(LRE_CURLSETOPT);
PYMODULE_ADDINTCONSTANT(LRE_ALREADYUSEDRESULT);
PYMODULE_ADDINTCONSTANT(LRE_INCOMPLETERESULT);
PYMODULE_ADDINTCONSTANT(LRE_CURLDUP);
PYMODULE_ADDINTCONSTANT(LRE_CURL);
PYMODULE_ADDINTCONSTANT(LRE_CURLM);
PYMODULE_ADDINTCONSTANT(LRE_BADSTATUS);
PYMODULE_ADDINTCONSTANT(LRE_TEMPORARYERR);
PYMODULE_ADDINTCONSTANT(LRE_NOTLOCAL);
PYMODULE_ADDINTCONSTANT(LRE_CANNOTCREATEDIR);
PYMODULE_ADDINTCONSTANT(LRE_IO);
PYMODULE_ADDINTCONSTANT(LRE_MLBAD);
PYMODULE_ADDINTCONSTANT(LRE_MLXML);
PYMODULE_ADDINTCONSTANT(LRE_BADCHECKSUM);
PYMODULE_ADDINTCONSTANT(LRE_REPOMDXML);
PYMODULE_ADDINTCONSTANT(LRE_NOURL);
PYMODULE_ADDINTCONSTANT(LRE_CANNOTCREATETMP);
PYMODULE_ADDINTCONSTANT(LRE_UNKNOWNCHECKSUM);
PYMODULE_ADDINTCONSTANT(LRE_BADURL);
PYMODULE_ADDINTCONSTANT(LRE_GPGNOTSUPPORTED);
PYMODULE_ADDINTCONSTANT(LRE_GPGERROR);
PYMODULE_ADDINTCONSTANT(LRE_BADGPG);
PYMODULE_ADDINTCONSTANT(LRE_INCOMPLETEREPO);
PYMODULE_ADDINTCONSTANT(LRE_INTERRUPTED);
PYMODULE_ADDINTCONSTANT(LRE_SIGACTION);
PYMODULE_ADDINTCONSTANT(LRE_ALREADYDOWNLOADED);
PYMODULE_ADDINTCONSTANT(LRE_UNFINISHED);
PYMODULE_ADDINTCONSTANT(LRE_SELECT);
PYMODULE_ADDINTCONSTANT(LRE_OPENSSL);
PYMODULE_ADDINTCONSTANT(LRE_MEMORY);
PYMODULE_ADDINTCONSTANT(LRE_XMLPARSER);
PYMODULE_ADDINTCONSTANT(LRE_CBINTERRUPTED);
PYMODULE_ADDINTCONSTANT(LRE_REPOMD);
PYMODULE_ADDINTCONSTANT(LRE_VALUE);
PYMODULE_ADDINTCONSTANT(LRE_NOTSET);
PYMODULE_ADDINTCONSTANT(LRE_FILE);
PYMODULE_ADDINTCONSTANT(LRE_KEYFILE);
PYMODULE_ADDINTCONSTANT(LRE_UNKNOWNERROR);
// Result option
PYMODULE_ADDINTCONSTANT(LRR_YUM_REPO);
PYMODULE_ADDINTCONSTANT(LRR_RPMMD_REPOMD);
PYMODULE_ADDINTCONSTANT(LRR_YUM_TIMESTAMP);
PYMODULE_ADDINTCONSTANT(LRR_RPMMD_REPO);
PYMODULE_ADDINTCONSTANT(LRR_YUM_REPOMD);
PYMODULE_ADDINTCONSTANT(LRR_RPMMD_TIMESTAMP);
PYMODULE_ADDINTCONSTANT(LRR_SENTINEL);
// Checksums
PYMODULE_ADDINTCONSTANT(LR_CHECKSUM_UNKNOWN);
PYMODULE_ADDINTCONSTANT(LR_CHECKSUM_MD5);
PYMODULE_ADDINTCONSTANT(LR_CHECKSUM_SHA1);
PYMODULE_ADDINTCONSTANT(LR_CHECKSUM_SHA224);
PYMODULE_ADDINTCONSTANT(LR_CHECKSUM_SHA256);
PYMODULE_ADDINTCONSTANT(LR_CHECKSUM_SHA384);
PYMODULE_ADDINTCONSTANT(LR_CHECKSUM_SHA512);
// Transfer statuses
PYMODULE_ADDINTCONSTANT(LR_TRANSFER_SUCCESSFUL);
PYMODULE_ADDINTCONSTANT(LR_TRANSFER_ALREADYEXISTS);
PYMODULE_ADDINTCONSTANT(LR_TRANSFER_ERROR);
// Fastest mirror stages
PYMODULE_ADDINTCONSTANT(LR_FMSTAGE_INIT);
PYMODULE_ADDINTCONSTANT(LR_FMSTAGE_CACHELOADING);
PYMODULE_ADDINTCONSTANT(LR_FMSTAGE_CACHELOADINGSTATUS);
PYMODULE_ADDINTCONSTANT(LR_FMSTAGE_DETECTION);
PYMODULE_ADDINTCONSTANT(LR_FMSTAGE_FINISHING);
PYMODULE_ADDINTCONSTANT(LR_FMSTAGE_STATUS);
// Callbacks return values
PYMODULE_ADDINTCONSTANT(LR_CB_OK);
PYMODULE_ADDINTCONSTANT(LR_CB_ABORT);
PYMODULE_ADDINTCONSTANT(LR_CB_ERROR);
// Init librepo library
lr_global_init();
#if PY_MAJOR_VERSION >= 3
return m;
#endif
}
void init_rpm(void)
{
PyObject * d, *o, *tag = NULL, *dict, *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(&rpmfi_Type) < 0) return;
if (PyType_Ready(&rpmmi_Type) < 0) return;
if (PyType_Ready(&rpmps_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_DECREF(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(&rpmfi_Type);
PyModule_AddObject(m, "fi", (PyObject *) &rpmfi_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(&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;
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
dict = PyDict_New();
{ const char *tname, *sname;
rpmtd names = rpmtdNew();
rpmTagGetNames(names, 1);
while ((tname = rpmtdNextString(names))) {
sname = tname + strlen("RPMTAG_");
tag = PyInt_FromLong(rpmTagGetValue(sname));
PyDict_SetItemString(d, tname, tag);
Py_DECREF(tag);
o = PyString_FromString(sname);
PyDict_SetItem(dict, tag, o);
Py_DECREF(o);
}
rpmtdFreeData(names);
rpmtdFree(names);
}
PyDict_SetItemString(d, "tagnames", dict);
Py_DECREF(dict);
#define REGISTER_ENUM(val) \
PyDict_SetItemString(d, #val, o=PyInt_FromLong( val )); \
Py_DECREF(o);
REGISTER_ENUM(RPMTAG_NOT_FOUND);
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_PREREQ);
REGISTER_ENUM(RPMSENSE_INTERP);
REGISTER_ENUM(RPMSENSE_SCRIPT_PRE);
REGISTER_ENUM(RPMSENSE_SCRIPT_POST);
REGISTER_ENUM(RPMSENSE_SCRIPT_PREUN);
REGISTER_ENUM(RPMSENSE_SCRIPT_POSTUN);
REGISTER_ENUM(RPMSENSE_SCRIPT_VERIFY);
REGISTER_ENUM(RPMSENSE_FIND_REQUIRES);
REGISTER_ENUM(RPMSENSE_FIND_PROVIDES);
REGISTER_ENUM(RPMSENSE_TRIGGERIN);
REGISTER_ENUM(RPMSENSE_TRIGGERUN);
REGISTER_ENUM(RPMSENSE_TRIGGERPOSTUN);
REGISTER_ENUM(RPMSENSE_SCRIPT_PREP);
REGISTER_ENUM(RPMSENSE_SCRIPT_BUILD);
REGISTER_ENUM(RPMSENSE_SCRIPT_INSTALL);
REGISTER_ENUM(RPMSENSE_SCRIPT_CLEAN);
REGISTER_ENUM(RPMSENSE_RPMLIB);
REGISTER_ENUM(RPMSENSE_TRIGGERPREIN);
REGISTER_ENUM(RPMSENSE_KEYRING);
REGISTER_ENUM(RPMSENSE_PATCHES);
REGISTER_ENUM(RPMSENSE_CONFIG);
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_KEEPOBSOLETE);
REGISTER_ENUM(RPMTRANS_FLAG_REPACKAGE);
REGISTER_ENUM(RPMTRANS_FLAG_REVERSE);
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_NOMD5);
REGISTER_ENUM(RPMTRANS_FLAG_NOSUGGEST);
REGISTER_ENUM(RPMTRANS_FLAG_ADDINDEPS);
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(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((intptr_t)RPMAL_NOMATCH);
}
PyMODINIT_FUNC initGPIO(void)
#endif
{
PyObject *module = NULL;
#if PY_MAJOR_VERSION > 2
if ((module = PyModule_Create(&rpigpiomodule)) == NULL)
goto exit;
#else
if ((module = Py_InitModule("RPi.GPIO", rpi_gpio_methods)) == NULL)
goto exit;
#endif
WrongDirectionException = PyErr_NewException("RPi.GPIO.WrongDirectionException", NULL, NULL);
PyModule_AddObject(module, "WrongDirectionException", WrongDirectionException);
InvalidModeException = PyErr_NewException("RPi.GPIO.InvalidModeException", NULL, NULL);
PyModule_AddObject(module, "InvalidModeException", InvalidModeException);
InvalidDirectionException = PyErr_NewException("RPi.GPIO.InvalidDirectionException", NULL, NULL);
PyModule_AddObject(module, "InvalidDirectionException", InvalidDirectionException);
InvalidChannelException = PyErr_NewException("RPi.GPIO.InvalidChannelException", NULL, NULL);
PyModule_AddObject(module, "InvalidChannelException", InvalidChannelException);
InvalidPullException = PyErr_NewException("RPi.GPIO.InvalidPullException", NULL, NULL);
PyModule_AddObject(module, "InvalidPullException", InvalidPullException);
ModeNotSetException = PyErr_NewException("RPi.GPIO.ModeNotSetException", NULL, NULL);
PyModule_AddObject(module, "ModeNotSetException", ModeNotSetException);
SetupException = PyErr_NewException("RPi.GPIO.SetupException", NULL, NULL);
PyModule_AddObject(module, "SetupException", SetupException);
high = Py_BuildValue("i", HIGH);
PyModule_AddObject(module, "HIGH", high);
low = Py_BuildValue("i", LOW);
PyModule_AddObject(module, "LOW", low);
output = Py_BuildValue("i", OUTPUT);
PyModule_AddObject(module, "OUT", output);
input = Py_BuildValue("i", INPUT);
PyModule_AddObject(module, "IN", input);
board = Py_BuildValue("i", BOARD);
PyModule_AddObject(module, "BOARD", board);
bcm = Py_BuildValue("i", BCM);
PyModule_AddObject(module, "BCM", bcm);
pud_off = Py_BuildValue("i", PUD_OFF);
PyModule_AddObject(module, "PUD_OFF", pud_off);
pud_up = Py_BuildValue("i", PUD_UP);
PyModule_AddObject(module, "PUD_UP", pud_up);
pud_down = Py_BuildValue("i", PUD_DOWN);
PyModule_AddObject(module, "PUD_DOWN", pud_down);
if (module_setup() != SETUP_OK)
{
#if PY_MAJOR_VERSION > 2
return NULL;
#else
return;
#endif
}
if (Py_AtExit(gpio_cleanup) != 0)
gpio_cleanup();
goto exit;
exit:
#if PY_MAJOR_VERSION > 2
return module;
#else
return;
#endif
}
PyMODINIT_FUNC initaudio(void) {
PyObject* module;
DeviceType.tp_new = PyType_GenericNew;
if (PyType_Ready(&DeviceType) < 0)
return;
if (PyType_Ready(&AudioQueueType) < 0)
return;
if (PyType_Ready(&ListenerType) < 0)
return;
if (PyType_Ready(&FilterType) < 0)
return;
if (PyType_Ready(&PythonFilterType) < 0)
return;
if (PyType_Ready(&CutoffFilterType) < 0)
return;
if (PyType_Ready(&CoalesceFilterType) < 0)
return;
if (PyType_Ready(&NegativeFilterType) < 0)
return;
if (PyType_Ready(&DecibelFilterType) < 0)
return;
PaError err = Pa_Initialize();
if (err != paNoError) {
PyErr_SetObject(PyExc_RuntimeError,
Py_BuildValue("(s, i)", "Failed to initialize PortAudio",
(int) err));
return;
}
if (Py_AtExit(terminate_portaudio) != 0) {
PySys_WriteStderr("Failed to register the PortAudio cleanup function.");
}
PyEval_InitThreads();
module = Py_InitModule3("audio", module_methods,
"Low-level audio processor");
if (module == NULL)
return;
Py_INCREF(&DeviceType);
PyModule_AddObject(module, "Device", (PyObject*) &DeviceType);
Py_INCREF(&AudioQueueType);
PyModule_AddObject(module, "Queue", (PyObject*) &AudioQueueType);
Py_INCREF(&ListenerType);
PyModule_AddObject(module, "Listener", (PyObject*) &ListenerType);
Py_INCREF(&FilterType);
PyModule_AddObject(module, "Filter", (PyObject*) &FilterType);
Py_INCREF(&PythonFilterType);
PyModule_AddObject(module, "PythonFilter", (PyObject*) &PythonFilterType);
Py_INCREF(&CutoffFilterType);
PyModule_AddObject(module, "CutoffFilter", (PyObject*) &CutoffFilterType);
Py_INCREF(&CoalesceFilterType);
PyModule_AddObject(module, "CoalesceFilter",
(PyObject*) &CoalesceFilterType);
Py_INCREF(&NegativeFilterType);
PyModule_AddObject(module, "NegativeFilter",
(PyObject*) &NegativeFilterType);
Py_INCREF(&DecibelFilterType);
PyModule_AddObject(module, "DecibelFilter",
(PyObject*) &DecibelFilterType);
}
PyMODINIT_FUNC
init_createrepo_c(void)
#endif
{
#if PY_MAJOR_VERSION >= 3
PyObject *m = PyModule_Create(&createrepo_c_module_def);
#else
PyObject *m = Py_InitModule("_createrepo_c", createrepo_c_methods);
#endif
if (!m)
return FAILURE;
/* Exceptions */
if (!init_exceptions())
return FAILURE;
PyModule_AddObject(m, "CreaterepoCError", CrErr_Exception);
/* Objects */
/* _createrepo_c.ContentStat */
if (PyType_Ready(&ContentStat_Type) < 0)
return FAILURE;
Py_INCREF(&ContentStat_Type);
PyModule_AddObject(m, "ContentStat", (PyObject *)&ContentStat_Type);
/* _createrepo_c.CrFile */
if (PyType_Ready(&CrFile_Type) < 0)
return FAILURE;
Py_INCREF(&CrFile_Type);
PyModule_AddObject(m, "CrFile", (PyObject *)&CrFile_Type);
/* _createrepo_c.Package */
if (PyType_Ready(&Package_Type) < 0)
return FAILURE;
Py_INCREF(&Package_Type);
PyModule_AddObject(m, "Package", (PyObject *)&Package_Type);
/* _createrepo_c.Metadata */
if (PyType_Ready(&Metadata_Type) < 0)
return FAILURE;
Py_INCREF(&Metadata_Type);
PyModule_AddObject(m, "Metadata", (PyObject *)&Metadata_Type);
/* _createrepo_c.MetadataLocation */
if (PyType_Ready(&MetadataLocation_Type) < 0)
return FAILURE;
Py_INCREF(&MetadataLocation_Type);
PyModule_AddObject(m, "MetadataLocation", (PyObject *)&MetadataLocation_Type);
/* _createrepo_c.Repomd */
if (PyType_Ready(&Repomd_Type) < 0)
return FAILURE;
Py_INCREF(&Repomd_Type);
PyModule_AddObject(m, "Repomd", (PyObject *)&Repomd_Type);
/* _createrepo_c.RepomdRecord */
if (PyType_Ready(&RepomdRecord_Type) < 0)
return FAILURE;
Py_INCREF(&RepomdRecord_Type);
PyModule_AddObject(m, "RepomdRecord", (PyObject *)&RepomdRecord_Type);
/* _createrepo_c.Sqlite */
if (PyType_Ready(&Sqlite_Type) < 0)
return FAILURE;
Py_INCREF(&Sqlite_Type);
PyModule_AddObject(m, "Sqlite", (PyObject *)&Sqlite_Type);
/* _createrepo_c.UpdateCollection */
if (PyType_Ready(&UpdateCollection_Type) < 0)
return FAILURE;
Py_INCREF(&UpdateCollection_Type);
PyModule_AddObject(m, "UpdateCollection",
(PyObject *)&UpdateCollection_Type);
/* _createrepo_c.UpdateCollectionPackage */
if (PyType_Ready(&UpdateCollectionPackage_Type) < 0)
return FAILURE;
Py_INCREF(&UpdateCollectionPackage_Type);
PyModule_AddObject(m, "UpdateCollectionPackage",
(PyObject *)&UpdateCollectionPackage_Type);
/* _createrepo_c.UpdateInfo */
if (PyType_Ready(&UpdateInfo_Type) < 0)
return FAILURE;
Py_INCREF(&UpdateInfo_Type);
PyModule_AddObject(m, "UpdateInfo", (PyObject *)&UpdateInfo_Type);
/* _createrepo_c.UpdateRecord */
if (PyType_Ready(&UpdateRecord_Type) < 0)
return FAILURE;
Py_INCREF(&UpdateRecord_Type);
PyModule_AddObject(m, "UpdateRecord", (PyObject *)&UpdateRecord_Type);
/* _createrepo_c.UpdateReference */
if (PyType_Ready(&UpdateReference_Type) < 0)
return FAILURE;
Py_INCREF(&UpdateReference_Type);
PyModule_AddObject(m, "UpdateReference", (PyObject *)&UpdateReference_Type);
/* _createrepo_c.XmlFile */
if (PyType_Ready(&XmlFile_Type) < 0)
return FAILURE;
Py_INCREF(&XmlFile_Type);
PyModule_AddObject(m, "XmlFile", (PyObject *)&XmlFile_Type);
/* Createrepo init */
cr_xml_dump_init();
cr_package_parser_init();
Py_AtExit(cr_xml_dump_cleanup);
Py_AtExit(cr_package_parser_cleanup);
/* Python macro to use datetime objects */
PyDateTime_IMPORT;
/* Module constants */
/* Version */
PyModule_AddIntConstant(m, "VERSION_MAJOR", CR_VERSION_MAJOR);
PyModule_AddIntConstant(m, "VERSION_MINOR", CR_VERSION_MINOR);
PyModule_AddIntConstant(m, "VERSION_PATCH", CR_VERSION_PATCH);
/* Checksum types */
PyModule_AddIntConstant(m, "CHECKSUM_UNKNOWN", CR_CHECKSUM_UNKNOWN);
PyModule_AddIntConstant(m, "MD5", CR_CHECKSUM_MD5);
PyModule_AddIntConstant(m, "SHA", CR_CHECKSUM_SHA);
PyModule_AddIntConstant(m, "SHA1", CR_CHECKSUM_SHA1);
PyModule_AddIntConstant(m, "SHA224", CR_CHECKSUM_SHA224);
PyModule_AddIntConstant(m, "SHA256", CR_CHECKSUM_SHA256);
PyModule_AddIntConstant(m, "SHA384", CR_CHECKSUM_SHA384);
PyModule_AddIntConstant(m, "SHA512", CR_CHECKSUM_SHA512);
/* File open modes */
PyModule_AddIntConstant(m, "MODE_READ", CR_CW_MODE_READ);
PyModule_AddIntConstant(m, "MODE_WRITE", CR_CW_MODE_WRITE);
/* Compression types */
PyModule_AddIntConstant(m, "AUTO_DETECT_COMPRESSION", CR_CW_AUTO_DETECT_COMPRESSION);
PyModule_AddIntConstant(m, "UNKNOWN_COMPRESSION", CR_CW_UNKNOWN_COMPRESSION);
PyModule_AddIntConstant(m, "NO_COMPRESSION", CR_CW_NO_COMPRESSION);
PyModule_AddIntConstant(m, "GZ_COMPRESSION", CR_CW_GZ_COMPRESSION);
PyModule_AddIntConstant(m, "BZ2_COMPRESSION", CR_CW_BZ2_COMPRESSION);
PyModule_AddIntConstant(m, "XZ_COMPRESSION", CR_CW_XZ_COMPRESSION);
/* Load Metadata key values */
PyModule_AddIntConstant(m, "HT_KEY_DEFAULT", CR_HT_KEY_DEFAULT);
PyModule_AddIntConstant(m, "HT_KEY_HASH", CR_HT_KEY_HASH);
PyModule_AddIntConstant(m, "HT_KEY_NAME", CR_HT_KEY_NAME);
PyModule_AddIntConstant(m, "HT_KEY_FILENAME", CR_HT_KEY_FILENAME);
/* Load Metadata key dup action */
PyModule_AddIntConstant(m, "HT_DUPACT_KEEPFIRST", CR_HT_DUPACT_KEEPFIRST);
PyModule_AddIntConstant(m, "HT_DUPACT_REMOVEALL", CR_HT_DUPACT_REMOVEALL);
/* Sqlite DB types */
PyModule_AddIntConstant(m, "DB_PRIMARY", CR_DB_PRIMARY);
PyModule_AddIntConstant(m, "DB_FILELISTS", CR_DB_FILELISTS);
PyModule_AddIntConstant(m, "DB_OTHER", CR_DB_OTHER);
/* XmlFile types */
PyModule_AddIntConstant(m, "XMLFILE_PRIMARY", CR_XMLFILE_PRIMARY);
PyModule_AddIntConstant(m, "XMLFILE_FILELISTS", CR_XMLFILE_FILELISTS);
PyModule_AddIntConstant(m, "XMLFILE_OTHER", CR_XMLFILE_OTHER);
PyModule_AddIntConstant(m, "XMLFILE_PRESTODELTA", CR_XMLFILE_PRESTODELTA);
PyModule_AddIntConstant(m, "XMLFILE_UPDATEINFO", CR_XMLFILE_UPDATEINFO);
/* XmlParser types */
PyModule_AddIntConstant(m, "XML_WARNING_UNKNOWNTAG", CR_XML_WARNING_UNKNOWNTAG);
PyModule_AddIntConstant(m, "XML_WARNING_MISSINGATTR", CR_XML_WARNING_MISSINGATTR);
PyModule_AddIntConstant(m, "XML_WARNING_UNKNOWNVAL", CR_XML_WARNING_UNKNOWNVAL);
PyModule_AddIntConstant(m, "XML_WARNING_BADATTRVAL", CR_XML_WARNING_BADATTRVAL);
#if PY_MAJOR_VERSION >= 3
return m;
#else
return;
#endif
}
/* Shared python2/3 module initialization: */
static int initModule(PyObject *m)
{
PyObject * d;
/*
* 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 0;
/* failure to initialize rpm (crypto and all) is rather fatal too... */
if (rpmReadConfigFiles(NULL, NULL) == -1)
return 0;
d = PyModule_GetDict(m);
pyrpmError = PyErr_NewException("_rpm.error", NULL, NULL);
if (pyrpmError != NULL)
PyDict_SetItemString(d, "error", pyrpmError);
Py_INCREF(&hdr_Type);
PyModule_AddObject(m, "hdr", (PyObject *) &hdr_Type);
Py_INCREF(&rpmarchive_Type);
PyModule_AddObject(m, "archive", (PyObject *) &rpmarchive_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(&rpmfi_Type);
PyModule_AddObject(m, "fi", (PyObject *) &rpmfi_Type);
Py_INCREF(&rpmfile_Type);
PyModule_AddObject(m, "file", (PyObject *) &rpmfile_Type);
Py_INCREF(&rpmfiles_Type);
PyModule_AddObject(m, "files", (PyObject *) &rpmfiles_Type);
Py_INCREF(&rpmKeyring_Type);
PyModule_AddObject(m, "keyring", (PyObject *) &rpmKeyring_Type);
Py_INCREF(&rpmmi_Type);
PyModule_AddObject(m, "mi", (PyObject *) &rpmmi_Type);
Py_INCREF(&rpmii_Type);
PyModule_AddObject(m, "ii", (PyObject *) &rpmii_Type);
Py_INCREF(&rpmProblem_Type);
PyModule_AddObject(m, "prob", (PyObject *) &rpmProblem_Type);
Py_INCREF(&rpmPubkey_Type);
PyModule_AddObject(m, "pubkey", (PyObject *) &rpmPubkey_Type);
Py_INCREF(&rpmstrPool_Type);
PyModule_AddObject(m, "strpool", (PyObject *) &rpmstrPool_Type);
#if 0
Py_INCREF(&rpmtd_Type);
PyModule_AddObject(m, "td", (PyObject *) &rpmtd_Type);
#endif
Py_INCREF(&rpmte_Type);
PyModule_AddObject(m, "te", (PyObject *) &rpmte_Type);
Py_INCREF(&rpmts_Type);
PyModule_AddObject(m, "ts", (PyObject *) &rpmts_Type);
addRpmTags(m);
PyModule_AddStringConstant(m, "__version__", RPMVERSION);
PyModule_AddObject(m, "header_magic",
PyBytes_FromStringAndSize((const char *)rpm_header_magic, 8));
#define REGISTER_ENUM(val) PyModule_AddIntConstant(m, #val, val)
REGISTER_ENUM(RPMTAG_NOT_FOUND);
REGISTER_ENUM(RPMRC_OK);
REGISTER_ENUM(RPMRC_NOTFOUND);
REGISTER_ENUM(RPMRC_FAIL);
REGISTER_ENUM(RPMRC_NOTTRUSTED);
REGISTER_ENUM(RPMRC_NOKEY);
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_SPECFILE);
REGISTER_ENUM(RPMFILE_GHOST);
REGISTER_ENUM(RPMFILE_LICENSE);
REGISTER_ENUM(RPMFILE_README);
REGISTER_ENUM(RPMFILE_PUBKEY);
REGISTER_ENUM(RPMDEP_SENSE_REQUIRES);
REGISTER_ENUM(RPMDEP_SENSE_CONFLICTS);
REGISTER_ENUM(RPMSENSE_ANY);
REGISTER_ENUM(RPMSENSE_LESS);
REGISTER_ENUM(RPMSENSE_GREATER);
REGISTER_ENUM(RPMSENSE_EQUAL);
REGISTER_ENUM(RPMSENSE_POSTTRANS);
REGISTER_ENUM(RPMSENSE_PREREQ);
REGISTER_ENUM(RPMSENSE_PRETRANS);
REGISTER_ENUM(RPMSENSE_INTERP);
REGISTER_ENUM(RPMSENSE_SCRIPT_PRE);
REGISTER_ENUM(RPMSENSE_SCRIPT_POST);
REGISTER_ENUM(RPMSENSE_SCRIPT_PREUN);
REGISTER_ENUM(RPMSENSE_SCRIPT_POSTUN);
REGISTER_ENUM(RPMSENSE_SCRIPT_VERIFY);
REGISTER_ENUM(RPMSENSE_FIND_REQUIRES);
REGISTER_ENUM(RPMSENSE_FIND_PROVIDES);
REGISTER_ENUM(RPMSENSE_TRIGGERIN);
REGISTER_ENUM(RPMSENSE_TRIGGERUN);
REGISTER_ENUM(RPMSENSE_TRIGGERPOSTUN);
REGISTER_ENUM(RPMSENSE_RPMLIB);
REGISTER_ENUM(RPMSENSE_TRIGGERPREIN);
REGISTER_ENUM(RPMSENSE_KEYRING);
REGISTER_ENUM(RPMSENSE_CONFIG);
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_NOPLUGINS);
REGISTER_ENUM(RPMTRANS_FLAG_KEEPOBSOLETE);
REGISTER_ENUM(RPMTRANS_FLAG_NOCONTEXTS);
REGISTER_ENUM(RPMTRANS_FLAG_REPACKAGE);
REGISTER_ENUM(RPMTRANS_FLAG_REVERSE);
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_NOPRETRANS);
REGISTER_ENUM(RPMTRANS_FLAG_NOPOSTTRANS);
REGISTER_ENUM(RPMTRANS_FLAG_NOMD5);
REGISTER_ENUM(RPMTRANS_FLAG_NOFILEDIGEST);
REGISTER_ENUM(RPMTRANS_FLAG_NOSUGGEST);
REGISTER_ENUM(RPMTRANS_FLAG_ADDINDEPS);
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(RPMCALLBACK_SCRIPT_START);
REGISTER_ENUM(RPMCALLBACK_SCRIPT_STOP);
REGISTER_ENUM(RPMCALLBACK_INST_STOP);
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_OBSOLETES);
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(RPMDBI_LABEL);
REGISTER_ENUM(RPMDBI_INSTFILENAMES);
REGISTER_ENUM(RPMDBI_NAME);
REGISTER_ENUM(RPMDBI_BASENAMES);
REGISTER_ENUM(RPMDBI_GROUP);
REGISTER_ENUM(RPMDBI_REQUIRENAME);
REGISTER_ENUM(RPMDBI_PROVIDENAME);
REGISTER_ENUM(RPMDBI_CONFLICTNAME);
REGISTER_ENUM(RPMDBI_OBSOLETENAME);
REGISTER_ENUM(RPMDBI_TRIGGERNAME);
REGISTER_ENUM(RPMDBI_DIRNAMES);
REGISTER_ENUM(RPMDBI_INSTALLTID);
REGISTER_ENUM(RPMDBI_SIGMD5);
REGISTER_ENUM(RPMDBI_SHA1HEADER);
REGISTER_ENUM(HEADERCONV_EXPANDFILELIST);
REGISTER_ENUM(HEADERCONV_COMPRESSFILELIST);
REGISTER_ENUM(HEADERCONV_RETROFIT_V3);
return 1;
}
PyMODINIT_FUNC initGPIO(void)
#endif
{
int i;
PyObject *module = NULL;
char cpuRev[1024] = {'\0'};
#if PY_MAJOR_VERSION > 2
if ((module = PyModule_Create(&lmkgpiomodule)) == NULL)
return NULL;
#else
if ((module = Py_InitModule3("LMK.GPIO", lmk_gpio_methods, moduledocstring)) == NULL)
return;
#endif
if (get_cpuinfo_revision(cpuRev) == NULL)
#if PY_MAJOR_VERSION > 2
return NULL;
#else
return;
#endif
revision = get_lmk_revision();
debug("BOARD: revision(%d)\n",revision);
define_constants(module);
for (i=0; i<256; i++)
gpio_direction[i] = -1;
if (revision == -1)
{
PyErr_SetString(PyExc_RuntimeError, "This module can only be run on a Raspberry Pi!");
setup_error = 1;
#if PY_MAJOR_VERSION > 2
return NULL;
#else
return;
#endif
}
lmk_revision = Py_BuildValue("i", revision);
PyModule_AddObject(module, "LMK_REVISION", lmk_revision);
// Add PWM class
if (PWM_init_PWMType() == NULL){
#if PY_MAJOR_VERSION > 2
return NULL;
#else
return;
#endif
}
Py_INCREF(&PWMType);
PyModule_AddObject(module, "PWM", (PyObject*)&PWMType);
if (!PyEval_ThreadsInitialized()){
PyEval_InitThreads();
}
//Initialized only once
if (mmap_gpio_mem())
#if PY_MAJOR_VERSION > 2
return NULL;
#else
return;
#endif
// register exit functions - last declared is called first
if (Py_AtExit(cleanup) != 0)
{
setup_error = 1;
cleanup();
#if PY_MAJOR_VERSION > 2
return NULL;
#else
return;
#endif
}
if (Py_AtExit(event_cleanup_all) != 0)
{
setup_error = 1;
cleanup();
#if PY_MAJOR_VERSION > 2
return NULL;
#else
return;
#endif
}
#if PY_MAJOR_VERSION > 2
return module;
#else
return;
#endif
}
PyMODINIT_FUNC initGPIO(void)
#endif
{
int i;
PyObject *module = NULL;
#if PY_MAJOR_VERSION > 2
if ((module = PyModule_Create(&rpigpiomodule)) == NULL)
return NULL;
#else
if ((module = Py_InitModule3("RPi.GPIO", rpi_gpio_methods, moduledocstring)) == NULL)
return;
#endif
define_constants(module);
for (i=0; i<54; i++)
gpio_direction[i] = -1;
// detect board revision and set up accordingly
revision = get_rpi_revision();
if (revision == -1)
{
PyErr_SetString(PyExc_RuntimeError, "This module can only be run on a Raspberry Pi!");
setup_error = 1;
#if PY_MAJOR_VERSION > 2
return NULL;
#else
return;
#endif
} else if (revision == 1) {
pin_to_gpio = &pin_to_gpio_rev1;
} else if (revision == 2) {
pin_to_gpio = &pin_to_gpio_rev2;
} else { // assume model B+
pin_to_gpio = &pin_to_gpio_rev3;
}
rpi_revision = Py_BuildValue("i", revision);
PyModule_AddObject(module, "RPI_REVISION", rpi_revision);
// Add PWM class
if (PWM_init_PWMType() == NULL)
#if PY_MAJOR_VERSION > 2
return NULL;
#else
return;
#endif
Py_INCREF(&PWMType);
PyModule_AddObject(module, "PWM", (PyObject*)&PWMType);
if (!PyEval_ThreadsInitialized())
PyEval_InitThreads();
// register exit functions - last declared is called first
if (Py_AtExit(cleanup) != 0)
{
setup_error = 1;
cleanup();
#if PY_MAJOR_VERSION > 2
return NULL;
#else
return;
#endif
}
if (Py_AtExit(event_cleanup_all) != 0)
{
setup_error = 1;
cleanup();
#if PY_MAJOR_VERSION > 2
return NULL;
#else
return;
#endif
}
#if PY_MAJOR_VERSION > 2
return module;
#else
return;
#endif
}
PyMODINIT_FUNC initGPIO(void)
#endif
{
PyObject *module = NULL;
#if PY_MAJOR_VERSION > 2
if ((module = PyModule_Create(&rpigpiomodule)) == NULL)
goto exit;
#else
if ((module = Py_InitModule("Ox.GPIO", rpi_gpio_methods)) == NULL)
goto exit;
#endif
WrongDirectionException = PyErr_NewException("Ox.GPIO.WrongDirectionException", NULL, NULL);
PyModule_AddObject(module, "WrongDirectionException", WrongDirectionException);
InvalidModeException = PyErr_NewException("Ox.GPIO.InvalidModeException", NULL, NULL);
PyModule_AddObject(module, "InvalidModeException", InvalidModeException);
InvalidDirectionException = PyErr_NewException("Ox.GPIO.InvalidDirectionException", NULL, NULL);
PyModule_AddObject(module, "InvalidDirectionException", InvalidDirectionException);
InvalidChannelException = PyErr_NewException("Ox.GPIO.InvalidChannelException", NULL, NULL);
PyModule_AddObject(module, "InvalidChannelException", InvalidChannelException);
InvalidPullException = PyErr_NewException("Ox.GPIO.InvalidPullException", NULL, NULL);
PyModule_AddObject(module, "InvalidPullException", InvalidPullException);
ModeNotSetException = PyErr_NewException("Ox.GPIO.ModeNotSetException", NULL, NULL);
PyModule_AddObject(module, "ModeNotSetException", ModeNotSetException);
SetupException = PyErr_NewException("Ox.GPIO.SetupException", NULL, NULL);
PyModule_AddObject(module, "SetupException", SetupException);
high = Py_BuildValue("i", HIGH);
PyModule_AddObject(module, "HIGH", high);
low = Py_BuildValue("i", LOW);
PyModule_AddObject(module, "LOW", low);
output = Py_BuildValue("i", OUTPUT);
PyModule_AddObject(module, "OUT", output);
input = Py_BuildValue("i", INPUT);
PyModule_AddObject(module, "IN", input);
version = Py_BuildValue("s", "0.4.1a");
PyModule_AddObject(module, "VERSION", version);
// set up mmaped areas
if (module_setup() != SETUP_OK )
{
#if PY_MAJOR_VERSION > 2
return NULL;
#else
return;
#endif
}
if (Py_AtExit(gpio_close) != 0)
{
gpio_close();
#if PY_MAJOR_VERSION > 2
return NULL;
#else
return;
#endif
}
exit:
#if PY_MAJOR_VERSION > 2
return module;
#else
return;
#endif
}
