From: Michael Tremer Date: Sun, 18 Dec 2016 17:37:32 +0000 (+0100) Subject: _pakfire: Implement Package based on libpakfire X-Git-Tag: 0.9.28~1285^2~1361 X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=233c52763a0b0115f07bee8bf22a0c999967d4bb;p=pakfire.git _pakfire: Implement Package based on libpakfire This wraps around libpakfire and enables Python to get access to packages. Signed-off-by: Michael Tremer --- diff --git a/src/_pakfire/_pakfiremodule.c b/src/_pakfire/_pakfiremodule.c index 2c998783b..9d55f4d01 100644 --- a/src/_pakfire/_pakfiremodule.c +++ b/src/_pakfire/_pakfiremodule.c @@ -28,6 +28,7 @@ #include "archive.h" #include "capabilities.h" #include "constants.h" +#include "package.h" #include "pool.h" #include "problem.h" #include "relation.h" @@ -82,10 +83,6 @@ static PyMethodDef Request_methods[] = { { NULL, NULL, 0, NULL } }; -static PyMethodDef Relation_methods[] = { - { NULL, NULL, 0, NULL } -}; - static PyMethodDef Solvable_methods[] = { {"get_name", (PyCFunction)Solvable_get_name, METH_NOARGS, NULL}, {"get_evr", (PyCFunction)Solvable_get_evr, METH_NOARGS, NULL}, @@ -193,6 +190,13 @@ PyMODINIT_FUNC PyInit__pakfire(void) { Py_INCREF(&ArchiveType); PyModule_AddObject(module, "Archive", (PyObject *)&ArchiveType); + // Package + if (PyType_Ready(&PackageType) < 0) + return NULL; + + Py_INCREF(&PackageType); + PyModule_AddObject(module, "Package", (PyObject *)&PackageType); + // Pool if (PyType_Ready(&PoolType) < 0) return NULL; @@ -221,9 +225,9 @@ PyMODINIT_FUNC PyInit__pakfire(void) { PyModule_AddObject(module, "Solvable", (PyObject *)&SolvableType); // Relation - RelationType.tp_methods = Relation_methods; if (PyType_Ready(&RelationType) < 0) return NULL; + Py_INCREF(&RelationType); PyModule_AddObject(module, "Relation", (PyObject *)&RelationType); diff --git a/src/_pakfire/package.c b/src/_pakfire/package.c index 22976de55..7e41df5c4 100644 --- a/src/_pakfire/package.c +++ b/src/_pakfire/package.c @@ -1,7 +1,7 @@ /*############################################################################# # # # Pakfire - The IPFire package management system # -# Copyright (C) 2016 Pakfire development team # +# Copyright (C) 2011 Pakfire development team # # # # This program is free software: you can redistribute it and/or modify # # it under the terms of the GNU General Public License as published by # @@ -20,9 +20,1093 @@ #include +#include +#include +#include +#include + #include "package.h" -#include "pool.h" +#include "relation.h" +#include "repo.h" PyObject* new_package(PoolObject* pool, Id id) { - return NULL; // XXX STUB + PyObject* args = Py_BuildValue("Oi", (PyObject *)pool, id); + PyObject* repo = PyObject_CallObject((PyObject *)&PackageType, args); + + Py_DECREF(args); + + return repo; +} + +static PyObject* Package_new(PyTypeObject* type, PyObject* args, PyObject* kwds) { + PackageObject* self = (PackageObject *)type->tp_alloc(type, 0); + if (self) { + self->pool = NULL; + self->package = NULL; + } + + return (PyObject *)self; +} + +static void Package_dealloc(PackageObject* self) { + if (self->package) + pakfire_package_free(self->package); + + Py_TYPE(self)->tp_free((PyObject *)self); +} + +static int Package_init(PackageObject* self, PyObject* args, PyObject* kwds) { + PyObject* pool; + int id = 0; + + if (!PyArg_ParseTuple(args, "O!|i", &PoolType, &pool, &id)) + return -1; + + self->pool = (PoolObject *)pool; + Py_INCREF(self->pool); + + self->package = pakfire_package_create(self->pool->pool, (Id)id); + + return 0; +} + +static long Package_hash(PackageObject* self) { + return pakfire_package_id(self->package); +} + +static PyObject* Package_repr(PackageObject* self) { + char* nevra = pakfire_package_get_nevra(self->package); + + PyObject* repr = PyUnicode_FromFormat("<_pakfire.Package object id %ld, %s>", + Package_hash(self), nevra); + pakfire_free(nevra); + + return repr; +} + +static PyObject* Package_str(PackageObject* self) { + char* nevra = pakfire_package_get_nevra(self->package); + + PyObject* str = PyUnicode_FromString(nevra); + pakfire_free(nevra); + + return str; +} + +static PyObject* Package_richcompare(PackageObject* self, PyObject* _other, int op) { + if (!PyType_IsSubtype(_other->ob_type, &PackageType)) { + PyErr_SetString(PyExc_TypeError, "Expected a Package object"); + return NULL; + } + + PackageObject* other = (PackageObject *)_other; + + long result = pakfire_package_cmp(self->package, other->package); + + switch (op) { + case Py_EQ: + if (result == 0) + Py_RETURN_TRUE; + break; + + case Py_NE: + if (result != 0) + Py_RETURN_TRUE; + break; + + case Py_LE: + if (result <= 0) + Py_RETURN_TRUE; + break; + + case Py_GE: + if (result >= 0) + Py_RETURN_TRUE; + break; + + case Py_LT: + if (result < 0) + Py_RETURN_TRUE; + break; + + case Py_GT: + if (result > 0) + Py_RETURN_TRUE; + break; + + default: + PyErr_BadArgument(); + return NULL; + } + + Py_RETURN_FALSE; +} + +static const char* PyUnicode_FromValue(PyObject* value) { + if (value == Py_None) + return NULL; + + return PyUnicode_AsUTF8(value); +} + +static PyObject* Package_get_name(PackageObject* self) { + const char* name = pakfire_package_get_name(self->package); + if (!name) + Py_RETURN_NONE; + + return PyUnicode_FromString(name); +} + +static void Package_set_name(PackageObject* self, PyObject* value) { + const char* name = PyUnicode_FromValue(value); + + pakfire_package_set_name(self->package, name); +} + +static PyObject* Package_get_epoch(PackageObject* self) { + unsigned long epoch = pakfire_package_get_epoch(self->package); + + return PyLong_FromLong(epoch); +} + +static PyObject* Package_get_version(PackageObject* self) { + const char* version = pakfire_package_get_version(self->package); + if (!version) + Py_RETURN_NONE; + + return PyUnicode_FromString(version); +} + +static PyObject* Package_get_release(PackageObject* self) { + const char* release = pakfire_package_get_release(self->package); + if (!release) + Py_RETURN_NONE; + + return PyUnicode_FromString(release); +} + +static PyObject* Package_get_evr(PackageObject* self) { + const char* evr = pakfire_package_get_evr(self->package); + if (!evr) + Py_RETURN_NONE; + + return PyUnicode_FromString(evr); +} + +static PyObject* Package_get_arch(PackageObject* self) { + const char* arch = pakfire_package_get_arch(self->package); + if (!arch) + Py_RETURN_NONE; + + return PyUnicode_FromString(arch); +} + +static void Package_set_arch(PackageObject* self, PyObject* value) { + const char* arch = PyUnicode_FromValue(value); + + pakfire_package_set_arch(self->package, arch); +} + +static PyObject* Package_get_uuid(PackageObject* self) { + const char* uuid = pakfire_package_get_uuid(self->package); + if (!uuid) + Py_RETURN_NONE; + + return PyUnicode_FromString(uuid); +} + +static void Package_set_uuid(PackageObject* self, PyObject* value) { + const char* uuid = PyUnicode_FromValue(value); + + pakfire_package_set_uuid(self->package, uuid); +} + +static PyObject* Package_get_checksum(PackageObject* self) { + const char* checksum = pakfire_package_get_checksum(self->package); + if (!checksum) + Py_RETURN_NONE; + + return PyUnicode_FromString(checksum); +} + +static void Package_set_checksum(PackageObject* self, PyObject* value) { + const char* checksum = PyUnicode_FromValue(value); + + pakfire_package_set_checksum(self->package, checksum); +} + +static PyObject* Package_get_summary(PackageObject* self) { + const char* summary = pakfire_package_get_summary(self->package); + if (!summary) + Py_RETURN_NONE; + + return PyUnicode_FromString(summary); +} + +static void Package_set_summary(PackageObject* self, PyObject* value) { + const char* summary = PyUnicode_FromValue(value); + + pakfire_package_set_summary(self->package, summary); +} + +static PyObject* Package_get_description(PackageObject* self) { + const char* description = pakfire_package_get_description(self->package); + if (!description) + Py_RETURN_NONE; + + return PyUnicode_FromString(description); +} + +static void Package_set_description(PackageObject* self, PyObject* value) { + const char* description = PyUnicode_FromValue(value); + + pakfire_package_set_description(self->package, description); +} + +static PyObject* Package_get_license(PackageObject* self) { + const char* license = pakfire_package_get_license(self->package); + if (!license) + Py_RETURN_NONE; + + return PyUnicode_FromString(license); +} + +static void Package_set_license(PackageObject* self, PyObject* value) { + const char* license = PyUnicode_FromValue(value); + + pakfire_package_set_summary(self->package, license); +} + +static PyObject* Package_get_url(PackageObject* self) { + const char* url = pakfire_package_get_url(self->package); + if (!url) + Py_RETURN_NONE; + + return PyUnicode_FromString(url); +} + +static void Package_set_url(PackageObject* self, PyObject* value) { + const char* url = PyUnicode_FromValue(value); + + pakfire_package_set_url(self->package, url); +} + +static PyObject* Package_get_groups(PackageObject* self) { + const char** groups = pakfire_package_get_groups(self->package); + + PyObject* list = PyList_New(0); + const char* group; + + while ((group = *groups++) != NULL) { + PyObject* item = PyUnicode_FromString(group); + PyList_Append(list, item); + + Py_DECREF(item); + } + + Py_INCREF(list); + return list; +} + +static int Package_set_groups(PackageObject* self, PyObject* value) { + if (!PySequence_Check(value)) { + PyErr_SetString(PyExc_AttributeError, "Expected a sequence."); + return -1; + } + + const int length = PySequence_Length(value); + const char* groups[length + 1]; + + for (int i = 0; i < length; i++) { + PyObject* item = PySequence_GetItem(value, i); + groups[i] = PyUnicode_AsUTF8(item); + + Py_DECREF(item); + } + groups[length] = NULL; + + pakfire_package_set_groups(self->package, groups); + + return 0; +} + +static PyObject* Package_get_vendor(PackageObject* self) { + const char* vendor = pakfire_package_get_vendor(self->package); + if (!vendor) + Py_RETURN_NONE; + + return PyUnicode_FromString(vendor); +} + +static void Package_set_vendor(PackageObject* self, PyObject* value) { + const char* vendor = PyUnicode_FromValue(value); + + pakfire_package_set_vendor(self->package, vendor); +} + +static PyObject* Package_get_maintainer(PackageObject* self) { + const char* maintainer = pakfire_package_get_maintainer(self->package); + if (!maintainer) + Py_RETURN_NONE; + + return PyUnicode_FromString(maintainer); +} + +static void Package_set_maintainer(PackageObject* self, PyObject* value) { + const char* maintainer = PyUnicode_FromValue(value); + + pakfire_package_set_maintainer(self->package, maintainer); +} + +static PyObject* Package_get_filename(PackageObject* self) { + const char* filename = pakfire_package_get_filename(self->package); + if (!filename) + Py_RETURN_NONE; + + return PyUnicode_FromString(filename); +} + +static void Package_set_filename(PackageObject* self, PyObject* value) { + const char* filename = PyUnicode_FromValue(value); + + pakfire_package_set_filename(self->package, filename); +} + +static PyObject* Package_get_installed(PackageObject* self) { + int installed = pakfire_package_is_installed(self->package); + + return PyBool_FromLong(installed); +} + +static PyObject* Package_get_downloadsize(PackageObject* self) { + unsigned long long size = pakfire_package_get_downloadsize(self->package); + + return PyLong_FromUnsignedLongLong(size); +} + +static void Package_set_downloadsize(PackageObject* self, PyObject* value) { + unsigned long downloadsize = PyLong_AsUnsignedLong(value); + + pakfire_package_set_downloadsize(self->package, downloadsize); +} + +static PyObject* Package_get_installsize(PackageObject* self) { + unsigned long long size = pakfire_package_get_installsize(self->package); + + return PyLong_FromUnsignedLongLong(size); +} + +static void Package_set_installsize(PackageObject* self, PyObject* value) { + unsigned long installsize = PyLong_AsUnsignedLong(value); + + pakfire_package_set_installsize(self->package, installsize); +} + +static PyObject* Package_get_size(PackageObject* self) { + unsigned long long size = pakfire_package_get_size(self->package); + + return PyLong_FromUnsignedLongLong(size); +} + +static PyObject* Package_get_buildhost(PackageObject* self) { + const char* buildhost = pakfire_package_get_buildhost(self->package); + if (!buildhost) + Py_RETURN_NONE; + + return PyUnicode_FromString(buildhost); +} + +static void Package_set_buildhost(PackageObject* self, PyObject* value) { + const char* buildhost = PyUnicode_FromValue(value); + + pakfire_package_set_buildhost(self->package, buildhost); } + +static PyObject* Package_get_buildtime(PackageObject* self) { + unsigned long long buildtime = pakfire_package_get_buildtime(self->package); + + return PyLong_FromUnsignedLongLong(buildtime); +} + +static void Package_set_buildtime(PackageObject* self, PyObject* value) { + unsigned long long buildtime = PyLong_AsUnsignedLongLong(value); + + pakfire_package_set_buildtime(self->package, buildtime); +} + +static PyObject* Package_get_cache_path(PackageObject* self) { + char* cache_path = pakfire_package_get_cache_path(self->package); + PyObject* ret = PyUnicode_FromString(cache_path); + pakfire_free(cache_path); + + return ret; +} + +static PyObject* Package_get_cache_full_path(PackageObject* self) { + char* cache_path = pakfire_package_get_cache_full_path(self->package); + PyObject* ret = PyUnicode_FromString(cache_path); + pakfire_free(cache_path); + + return ret; +} + +static PyObject* Package_get_repo(PackageObject* self) { + PakfireRepo repo = pakfire_package_get_repo(self->package); + + if (!repo) + return NULL; + + const char* name = pakfire_repo_get_name(repo); + pakfire_repo_free(repo); + + return new_repo(self->pool, name); +} + +static int Package_set_repo(PackageObject* self, PyObject* value) { + #warning TODO Package_set_repo + return -1; +} + +static PyObject* Package_get_location(PackageObject* self) { + char* location = pakfire_package_get_location(self->package); + + PyObject* str = PyUnicode_FromString(location); + pakfire_free(location); + + return str; +} + +static PyObject* PyList_FromRelationList(PoolObject* pool, PakfireRelationList relationlist) { + PyObject* list = PyList_New(0); + if (list == NULL) + return NULL; + + const int count = pakfire_relationlist_count(relationlist); + + for (int i = 0; i < count; i++) { + PakfireRelation relation = pakfire_relationlist_get_clone(relationlist, i); + PyObject* relation_obj = new_relation(pool, pakfire_relation_id(relation)); + + pakfire_relation_free(relation); + if (relation_obj == NULL) + goto fail; + + int ret = PyList_Append(list, relation_obj); + Py_DECREF(relation_obj); + + if (ret == -1) + goto fail; + } + + return list; + +fail: + Py_DECREF(list); + return NULL; +} + +static PakfireRelationList PyList_AsRelationList(PoolObject* pool, PyObject* value) { + if (!PySequence_Check(value)) { + PyErr_SetString(PyExc_AttributeError, "Expected a sequence."); + return NULL; + } + + const int length = PySequence_Length(value); + PakfireRelationList relationlist = pakfire_relationlist_create(pool->pool); + + for (int i = 0; i < length; i++) { + PyObject* item = PySequence_GetItem(value, i); + + if (!PyObject_TypeCheck(item, &RelationType)) { + pakfire_relationlist_free(relationlist); + Py_DECREF(item); + + PyErr_SetString(PyExc_AttributeError, "Expected a Relation object"); + return NULL; + } + + RelationObject* relation = (RelationObject *)item; + pakfire_relationlist_add(relationlist, relation->relation); + + Py_DECREF(item); + } + + return relationlist; +} + +static PyObject* Package_get_provides(PackageObject* self) { + PakfireRelationList relationlist = pakfire_package_get_provides(self->package); + + PyObject* list = PyList_FromRelationList(self->pool, relationlist); + pakfire_relationlist_free(relationlist); + + return list; +} + +static int Package_set_provides(PackageObject* self, PyObject* value) { + PakfireRelationList relationlist = PyList_AsRelationList(self->pool, value); + if (!relationlist) + return -1; + + pakfire_package_set_provides(self->package, relationlist); + pakfire_relationlist_free(relationlist); + + return 0; +} + +static PyObject* Package_add_provides(PackageObject* self, PyObject* args) { + RelationObject* relation = NULL; + + if (!PyArg_ParseTuple(args, "O!", &RelationType, &relation)) + return NULL; + + pakfire_package_add_provides(self->package, relation->relation); + + Py_RETURN_NONE; +} + +static PyObject* Package_get_requires(PackageObject* self) { + PakfireRelationList relationlist = pakfire_package_get_requires(self->package); + + PyObject* list = PyList_FromRelationList(self->pool, relationlist); + pakfire_relationlist_free(relationlist); + + return list; +} + +static int Package_set_requires(PackageObject* self, PyObject* value) { + PakfireRelationList relationlist = PyList_AsRelationList(self->pool, value); + if (!relationlist) + return -1; + + pakfire_package_set_requires(self->package, relationlist); + pakfire_relationlist_free(relationlist); + + return 0; +} + +static PyObject* Package_add_requires(PackageObject* self, PyObject* args) { + RelationObject* relation = NULL; + + if (!PyArg_ParseTuple(args, "O!", &RelationType, &relation)) + return NULL; + + pakfire_package_add_requires(self->package, relation->relation); + + Py_RETURN_NONE; +} + +static PyObject* Package_get_obsoletes(PackageObject* self) { + PakfireRelationList relationlist = pakfire_package_get_obsoletes(self->package); + + PyObject* list = PyList_FromRelationList(self->pool, relationlist); + pakfire_relationlist_free(relationlist); + + return list; +} + +static int Package_set_obsoletes(PackageObject* self, PyObject* value) { + PakfireRelationList relationlist = PyList_AsRelationList(self->pool, value); + if (!relationlist) + return -1; + + pakfire_package_set_obsoletes(self->package, relationlist); + pakfire_relationlist_free(relationlist); + + return 0; +} + +static PyObject* Package_add_obsoletes(PackageObject* self, PyObject* args) { + RelationObject* relation = NULL; + + if (!PyArg_ParseTuple(args, "O!", &RelationType, &relation)) + return NULL; + + pakfire_package_add_obsoletes(self->package, relation->relation); + + Py_RETURN_NONE; +} + +static PyObject* Package_get_conflicts(PackageObject* self) { + PakfireRelationList relationlist = pakfire_package_get_conflicts(self->package); + + PyObject* list = PyList_FromRelationList(self->pool, relationlist); + pakfire_relationlist_free(relationlist); + + return list; +} + +static int Package_set_conflicts(PackageObject* self, PyObject* value) { + PakfireRelationList relationlist = PyList_AsRelationList(self->pool, value); + if (!relationlist) + return -1; + + pakfire_package_set_conflicts(self->package, relationlist); + pakfire_relationlist_free(relationlist); + + return 0; +} + +static PyObject* Package_add_conflicts(PackageObject* self, PyObject* args) { + RelationObject* relation = NULL; + + if (!PyArg_ParseTuple(args, "O!", &RelationType, &relation)) + return NULL; + + pakfire_package_add_conflicts(self->package, relation->relation); + + Py_RETURN_NONE; +} + +static PyObject* Package_get_recommends(PackageObject* self) { + PakfireRelationList relationlist = pakfire_package_get_recommends(self->package); + + PyObject* list = PyList_FromRelationList(self->pool, relationlist); + pakfire_relationlist_free(relationlist); + + return list; +} + +static int Package_set_recommends(PackageObject* self, PyObject* value) { + PakfireRelationList relationlist = PyList_AsRelationList(self->pool, value); + if (!relationlist) + return -1; + + pakfire_package_set_recommends(self->package, relationlist); + pakfire_relationlist_free(relationlist); + + return 0; +} + +static PyObject* Package_add_recommends(PackageObject* self, PyObject* args) { + RelationObject* relation = NULL; + + if (!PyArg_ParseTuple(args, "O!", &RelationType, &relation)) + return NULL; + + pakfire_package_add_recommends(self->package, relation->relation); + + Py_RETURN_NONE; +} + +static PyObject* Package_get_suggests(PackageObject* self) { + PakfireRelationList relationlist = pakfire_package_get_suggests(self->package); + + PyObject* list = PyList_FromRelationList(self->pool, relationlist); + pakfire_relationlist_free(relationlist); + + return list; +} + +static int Package_set_suggests(PackageObject* self, PyObject* value) { + PakfireRelationList relationlist = PyList_AsRelationList(self->pool, value); + if (!relationlist) + return -1; + + pakfire_package_set_suggests(self->package, relationlist); + pakfire_relationlist_free(relationlist); + + return 0; +} + +static PyObject* Package_add_suggests(PackageObject* self, PyObject* args) { + RelationObject* relation = NULL; + + if (!PyArg_ParseTuple(args, "O!", &RelationType, &relation)) + return NULL; + + pakfire_package_add_suggests(self->package, relation->relation); + + Py_RETURN_NONE; +} + +static PyObject* Package_get_filelist(PackageObject* self, PyObject* args) { + PyObject* list = PyList_New(0); + if (list == NULL) + return NULL; + + PakfireFile file = pakfire_package_get_filelist(self->package); + while (file) { + const char* name = pakfire_file_get_name(file); + + PyObject* obj = PyUnicode_FromString(name); + + int ret = PyList_Append(list, obj); + Py_DECREF(obj); + + if (ret == -1) + goto fail; + + file = pakfire_file_get_next(file); + } + + return list; + +fail: + Py_DECREF(list); + return NULL; +} + +static int Package_set_filelist(PackageObject* self, PyObject* value) { + if (!PySequence_Check(value)) { + PyErr_SetString(PyExc_AttributeError, "Expected a sequence."); + return -1; + } + + PakfirePackage pkg = self->package; + pakfire_package_filelist_remove(pkg); + + const int length = PySequence_Length(value); + for (int i = 0; i < length; i++) { + PyObject* item = PySequence_GetItem(value, i); + + if (!PyUnicode_Check(item)) { + Py_DECREF(item); + + PyErr_SetString(PyExc_AttributeError, "Expected a string"); + return -1; + } + + const char* name = PyUnicode_AsUTF8(item); + + PakfireFile file = pakfire_package_filelist_append(pkg, name); + +# if 0 + PakfireFile file = pakfire_package_filelist_append(pkg); + pakfire_file_set_name(file, name); +#endif + + Py_DECREF(item); + } + + return 0; +} + +static PyObject* Package_dump(PackageObject* self, PyObject *args, PyObject* kwds) { + static char* kwlist[] = {"long", "filelist", NULL}; + + int long_format = 0; + int filelist = 0; + + if (!PyArg_ParseTupleAndKeywords(args, kwds, "|ii", kwlist, &long_format, &filelist)) + return NULL; + + int flags = 0; + if (long_format) + flags |= PAKFIRE_PKG_DUMP_LONG; + + if (filelist) + flags |= PAKFIRE_PKG_DUMP_FILELIST; + + char* package_dump = pakfire_package_dump(self->package, flags); + + if (!package_dump) + Py_RETURN_NONE; + + return PyUnicode_FromString(package_dump); +} + +static struct PyMethodDef Package_methods[] = { + { + "add_provides", + (PyCFunction)Package_add_provides, + METH_VARARGS, + NULL + }, + { + "add_requires", + (PyCFunction)Package_add_requires, + METH_VARARGS, + NULL + }, + { + "add_conflicts", + (PyCFunction)Package_add_conflicts, + METH_VARARGS, + NULL + }, + { + "add_obsoletes", + (PyCFunction)Package_add_obsoletes, + METH_VARARGS, + NULL + }, + { + "add_recommends", + (PyCFunction)Package_add_recommends, + METH_VARARGS, + NULL + }, + { + "add_suggests", + (PyCFunction)Package_add_suggests, + METH_VARARGS, + NULL + }, + { + "dump", + (PyCFunction)Package_dump, + METH_VARARGS|METH_KEYWORDS, + NULL + }, + { NULL }, +}; + +static struct PyGetSetDef Package_getsetters[] = { + { + "name", + (getter)Package_get_name, + (setter)Package_set_name, + NULL, + NULL + }, + { + "epoch", + (getter)Package_get_epoch, + NULL, + NULL, + NULL + }, + { + "version", + (getter)Package_get_version, + NULL, + NULL, + NULL + }, + { + "release", + (getter)Package_get_release, + NULL, + NULL, + NULL + }, + { + "evr", + (getter)Package_get_evr, + NULL, + NULL, + NULL + }, + { + "arch", + (getter)Package_get_arch, + (setter)Package_set_arch, + NULL, + NULL + }, + { + "uuid", + (getter)Package_get_uuid, + (setter)Package_set_uuid, + NULL, + NULL + }, + { + "checksum", + (getter)Package_get_checksum, + (setter)Package_set_checksum, + NULL, + NULL + }, + { + "summary", + (getter)Package_get_summary, + (setter)Package_set_summary, + NULL, + NULL + }, + { + "description", + (getter)Package_get_description, + (setter)Package_set_description, + NULL, + NULL + }, + { + "license", + (getter)Package_get_license, + (setter)Package_set_license, + NULL, + NULL + }, + { + "url", + (getter)Package_get_url, + (setter)Package_set_url, + NULL, + NULL + }, + { + "groups", + (getter)Package_get_groups, + (setter)Package_set_groups, + NULL, + NULL + }, + { + "vendor", + (getter)Package_get_vendor, + (setter)Package_set_vendor, + NULL, + NULL + }, + { + "maintainer", + (getter)Package_get_maintainer, + (setter)Package_set_maintainer, + NULL, + NULL + }, + { + "filename", + (getter)Package_get_filename, + (setter)Package_set_filename, + NULL, + NULL + }, + { + "installed", + (getter)Package_get_installed, + NULL, + NULL, + NULL + }, + { + "downloadsize", + (getter)Package_get_downloadsize, + (setter)Package_set_downloadsize, + NULL, + NULL + }, + { + "installsize", + (getter)Package_get_installsize, + (setter)Package_set_installsize, + NULL, + NULL + }, + { + "size", + (getter)Package_get_size, + NULL, + NULL, + NULL + }, + { + "buildhost", + (getter)Package_get_buildhost, + (setter)Package_set_buildhost, + NULL, + NULL + }, + { + "buildtime", + (getter)Package_get_buildtime, + (setter)Package_set_buildtime, + NULL, + NULL + }, + { + "cache_path", + (getter)Package_get_cache_path, + NULL, + NULL, + NULL + }, + { + "cache_full_path", + (getter)Package_get_cache_full_path, + NULL, + NULL, + NULL + }, + + // Dependencies + { + "provides", + (getter)Package_get_provides, + (setter)Package_set_provides, + NULL, + NULL + }, + { + "requires", + (getter)Package_get_requires, + (setter)Package_set_requires, + NULL, + NULL + }, + { + "obsoletes", + (getter)Package_get_obsoletes, + (setter)Package_set_obsoletes, + NULL, + NULL + }, + { + "conflicts", + (getter)Package_get_conflicts, + (setter)Package_set_conflicts, + NULL, + NULL + }, + { + "recommends", + (getter)Package_get_recommends, + (setter)Package_set_recommends, + NULL, + NULL + }, + { + "suggests", + (getter)Package_get_suggests, + (setter)Package_set_suggests, + NULL, + NULL + }, + + // Repository + { + "repo", + (getter)Package_get_repo, + (setter)Package_set_repo, + NULL, + NULL + }, + { + "location", + (getter)Package_get_location, + NULL, + NULL, + NULL + }, + + // Filelist + { + "filelist", + (getter)Package_get_filelist, + (setter)Package_set_filelist, + NULL, + NULL + }, + + { NULL } +}; + +PyTypeObject PackageType = { + PyVarObject_HEAD_INIT(NULL, 0) + tp_name: "_pakfire.Package", + tp_basicsize: sizeof(PackageObject), + tp_flags: Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, + tp_new: Package_new, + tp_dealloc: (destructor)Package_dealloc, + tp_init: (initproc)Package_init, + tp_doc: "Package object", + tp_methods: Package_methods, + tp_getset: Package_getsetters, + tp_hash: (hashfunc)Package_hash, + tp_repr: (reprfunc)Package_repr, + tp_str: (reprfunc)Package_str, + tp_richcompare: (richcmpfunc)Package_richcompare, +}; diff --git a/src/_pakfire/package.h b/src/_pakfire/package.h index 47bf215f4..530dbb09e 100644 --- a/src/_pakfire/package.h +++ b/src/_pakfire/package.h @@ -1,7 +1,7 @@ /*############################################################################# # # # Pakfire - The IPFire package management system # -# Copyright (C) 2016 Pakfire development team # +# Copyright (C) 2011 Pakfire development team # # # # This program is free software: you can redistribute it and/or modify # # it under the terms of the GNU General Public License as published by # @@ -23,8 +23,19 @@ #include +#include +#include + #include "pool.h" +typedef struct { + PyObject_HEAD + PoolObject* pool; + PakfirePackage package; +} PackageObject; + +extern PyTypeObject PackageType; + PyObject* new_package(PoolObject* pool, Id id); #endif /* PYTHON_PAKFIRE_PACKAGE_H */ diff --git a/src/_pakfire/relation.c b/src/_pakfire/relation.c index ec5167886..ef1363975 100644 --- a/src/_pakfire/relation.c +++ b/src/_pakfire/relation.c @@ -18,57 +18,134 @@ # # #############################################################################*/ -#include "pool.h" -#include "relation.h" - -#define REL_NONE 0 +#include -PyTypeObject RelationType = { - PyVarObject_HEAD_INIT(NULL, 0) - tp_name: "_pakfire.Relation", - tp_basicsize: sizeof(RelationObject), - tp_flags: Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, - tp_new : Relation_new, - tp_dealloc: (destructor) Relation_dealloc, - tp_doc: "Sat Relation objects", - tp_str: (reprfunc)Relation_string, -}; +#include +#include +#include +#include +#include -PyObject* Relation_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { - RelationObject *self; - PoolObject *pool; - const char *name; - const char *evr = NULL; - int flags = 0; +#include "package.h" +#include "relation.h" - if (!PyArg_ParseTuple(args, "Os|si", &pool, &name, &evr, &flags)) { - /* XXX raise exception */ +static RelationObject* Relation_new_core(PyTypeObject* type, PoolObject* pool) { + RelationObject* self = (RelationObject *)type->tp_alloc(type, 0); + if (!self) return NULL; + + if (pool) { + self->pool = pool; + Py_INCREF(self->pool); } - Id _name = pool_str2id(pool->_pool, name, 1); + self->relation = NULL; - self = (RelationObject *)type->tp_alloc(type, 0); - if (self != NULL) { - if (flags == REL_NONE) { - self->_id = _name; - } else { - Id _evr = pool_str2id(pool->_pool, evr, 1); - self->_id = pool_rel2id(pool->_pool, _name, _evr, flags, 1); - } + return self; +} - self->_pool = pool->_pool; - } +PyObject* new_relation(PoolObject* pool, Id id) { + RelationObject* relation = Relation_new_core(&RelationType, pool); + relation->relation = pakfire_relation_create_from_id(pool->pool, id); + + return (PyObject *)relation; +} + +static PyObject* Relation_new(PyTypeObject* type, PyObject* args, PyObject* kwds) { + RelationObject* self = Relation_new_core(type, NULL); return (PyObject *)self; } -PyObject *Relation_dealloc(RelationObject *self) { +static void Relation_dealloc(RelationObject* self) { + if (self->relation) + pakfire_relation_free(self->relation); + + Py_XDECREF(self->pool); Py_TYPE(self)->tp_free((PyObject *)self); +} + +static int Relation_init(RelationObject* self, PyObject* args, PyObject* kwds) { + PyObject* pool; + const char* name; + const char* evr = NULL; + int cmp_type = 0; - Py_RETURN_NONE; + if (!PyArg_ParseTuple(args, "O!s|is", &PoolType, &pool, &name, &cmp_type, &evr)) + return -1; + + self->pool = (PoolObject *)pool; + Py_INCREF(self->pool); + + self->relation = pakfire_relation_create(self->pool->pool, name, cmp_type, evr); + if (!self->relation) { + PyErr_Format(PyExc_ValueError, "No such relation: %s", name); + return -1; + } + + return 0; } -PyObject *Relation_string(RelationObject *self) { - return Py_BuildValue("s", pool_dep2str(self->_pool, self->_id)); +static long Relation_hash(RelationObject* self) { + return pakfire_relation_id(self->relation); } + +static PyObject* Relation_repr(RelationObject* self) { + char* relation = pakfire_relation_str(self->relation); + + PyObject* repr = PyUnicode_FromFormat("<_pakfire.Relation %s>", relation); + pakfire_free(relation); + + return repr; +} + +static PyObject* Relation_str(RelationObject* self) { + char* relation = pakfire_relation_str(self->relation); + + PyObject* str = PyUnicode_FromString(relation); + pakfire_free(relation); + + return str; +} + +static PyObject* Relation_get_providers(RelationObject* self) { + PakfirePackageList packagelist = pakfire_relation_providers(self->relation); + + PyObject* list = PyList_New(0); + PakfirePackage package; + int i; + + FOR_PACKAGELIST(package, packagelist, i) { + PyObject* obj = new_package(self->pool, pakfire_package_id(package)); + PyList_Append(list, obj); + } + pakfire_packagelist_free(packagelist); + + return list; +} + +static struct PyGetSetDef Relation_getsetters[] = { + { + "providers", + (getter)Relation_get_providers, + NULL, + NULL, + NULL + }, + { NULL }, +}; + +PyTypeObject RelationType = { + PyVarObject_HEAD_INIT(NULL, 0) + tp_name: "_pakfire.Relation", + tp_basicsize: sizeof(RelationObject), + tp_flags: Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, + tp_new: Relation_new, + tp_dealloc: (destructor)Relation_dealloc, + tp_init: (initproc)Relation_init, + tp_doc: "Relation object", + tp_hash: (hashfunc)Relation_hash, + tp_repr: (reprfunc)Relation_repr, + tp_str: (reprfunc)Relation_str, + tp_getset: Relation_getsetters, +}; diff --git a/src/_pakfire/relation.h b/src/_pakfire/relation.h index 348fa22eb..2a236ac60 100644 --- a/src/_pakfire/relation.h +++ b/src/_pakfire/relation.h @@ -23,20 +23,23 @@ #include -#include +#include +#include + +#include "pool.h" -// Sat Relation object typedef struct { PyObject_HEAD - Pool *_pool; - Id _id; -} RelationObject; - -extern PyObject *Relation_new(PyTypeObject *type, PyObject *args, PyObject *kwds); -extern PyObject *Relation_dealloc(RelationObject *self); + PoolObject* pool; + PakfireRelation relation; -extern PyObject *Relation_string(RelationObject *self); + // XXX COMPAT + Pool* _pool; + Id _id; +} RelationObject; extern PyTypeObject RelationType; +PyObject* new_relation(PoolObject* pool, Id id); + #endif /* PYTHON_PAKFIRE_RELATION_H */