filelist: Change type from PakfireFilelist to struct pakfire_filelist

[people/ms/pakfire.git] / src / _pakfire / package.c

/*#############################################################################
#                                                                             #
# Pakfire - The IPFire package management system                              #
# 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        #
# the Free Software Foundation, either version 3 of the License, or           #
# (at your option) any later version.                                         #
#                                                                             #
# This program is distributed in the hope that it will be useful,             #
# but WITHOUT ANY WARRANTY; without even the implied warranty of              #
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               #
# GNU General Public License for more details.                                #
#                                                                             #
# You should have received a copy of the GNU General Public License           #
# along with this program.  If not, see <http://www.gnu.org/licenses/>.       #
#                                                                             #
#############################################################################*/

#include <Python.h>

#include <pakfire/file.h>
#include <pakfire/filelist.h>
#include <pakfire/package.h>
#include <pakfire/repo.h>
#include <pakfire/util.h>

#include "package.h"
#include "pakfire.h"
#include "repo.h"
#include "util.h"

PyObject* new_package(PyTypeObject* type, struct pakfire_package* pkg) {
	PackageObject* self = (PackageObject *)type->tp_alloc(type, 0);
	if (self) {
		self->package = pakfire_package_ref(pkg);
	}

	return (PyObject *)self;
}

static PyObject* Package_new(PyTypeObject* type, PyObject* args, PyObject* kwds) {
	PackageObject* self = (PackageObject *)type->tp_alloc(type, 0);
	if (self) {
		self->package = NULL;
	}

	return (PyObject *)self;
}

static void Package_dealloc(PackageObject* self) {
	pakfire_package_unref(self->package);

	Py_TYPE(self)->tp_free((PyObject *)self);
}

static int Package_init(PackageObject* self, PyObject* args, PyObject* kwds) {
	PakfireObject* pakfire;
	RepoObject* repo;
	const char* name = NULL;
	const char* evr = NULL;
	const char* arch = NULL;

	if (!PyArg_ParseTuple(args, "O!O!sss", &PakfireType, &pakfire, &RepoType, &repo,
			&name, &evr, &arch))
		return -1;

	self->package = pakfire_package_create(pakfire->pakfire, repo->repo, name, evr, arch);
	if (!self->package) {
		PyErr_SetFromErrno(PyExc_OSError);
		return -1;
	}

	return 0;
}

static PyObject* Package_repr(PackageObject* self) {
	const char* nevra = pakfire_package_get_nevra(self->package);

	return PyUnicode_FromFormat("<_pakfire.Package %s>", nevra);
}

static PyObject* Package_str(PackageObject* self) {
	const char* nevra = pakfire_package_get_nevra(self->package);

	return PyUnicode_FromString(nevra);
}

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_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* s = pakfire_package_get_groups(self->package);

	return PyUnicode_FromString(s);
}

static int Package_set_groups(PackageObject* self, PyObject* value) {
	const char* groups = PyUnicode_AsUTF8(value);

	if (groups)
		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* build_host = pakfire_package_get_build_host(self->package);
	if (!build_host)
		Py_RETURN_NONE;

	return PyUnicode_FromString(build_host);
}

static void Package_set_buildhost(PackageObject* self, PyObject* value) {
	const char* build_host = PyUnicode_FromValue(value);

	pakfire_package_set_build_host(self->package, build_host);
}

static PyObject* Package_get_buildtime(PackageObject* self) {
	time_t build_time = pakfire_package_get_build_time(self->package);

	return PyLong_FromUnsignedLongLong(build_time);
}

static void Package_set_buildtime(PackageObject* self, PyObject* value) {
	time_t build_time = PyLong_AsUnsignedLongLong(value);

	pakfire_package_set_build_time(self->package, build_time);
}

static PyObject* Package_get_repo(PackageObject* self) {
	struct pakfire_repo* repo = pakfire_package_get_repo(self->package);
	if (!repo)
		Py_RETURN_NONE;

	PyObject* obj = new_repo(&RepoType, repo);
	pakfire_repo_unref(repo);

	return obj;
}

static PyObject* Package_get_path(PackageObject* self) {
	const char* path = pakfire_package_get_path(self->package);
	if (!path) {
		PyErr_SetFromErrno(PyExc_OSError);
		return NULL;
	}

	return PyUnicode_FromString(path);
}

static PyObject* PyList_FromRelationList(char** deps) {
	PyObject* list = PyList_New(0);
	if (list == NULL)
		return NULL;

	// Empty list?
	if (!deps)
		return list;

	for (char** dep = deps; *dep; dep++) {
		PyObject* obj = PyUnicode_FromString(*dep);
		if (!obj)
			break;

		PyList_Append(list, obj);
		Py_DECREF(obj);
	}

	return list;
}

static PyObject* Package_get_provides(PackageObject* self) {
	char** deps = pakfire_package_get_provides(self->package);

	PyObject* list = PyList_FromRelationList(deps);

	if (deps) {
		for (char** dep = deps; *dep; dep++)
			free(*dep);
		free(deps);
	}

	return list;
}

static PyObject* Package_get_requires(PackageObject* self) {
	char** deps = pakfire_package_get_requires(self->package);

	PyObject* list = PyList_FromRelationList(deps);

	if (deps) {
		for (char** dep = deps; *dep; dep++)
			free(*dep);
		free(deps);
	}

	return list;
}

static PyObject* Package_get_obsoletes(PackageObject* self) {
	char** deps = pakfire_package_get_obsoletes(self->package);

	PyObject* list = PyList_FromRelationList(deps);

	if (deps) {
		for (char** dep = deps; *dep; dep++)
			free(*dep);
		free(deps);
	}

	return list;
}

static PyObject* Package_get_conflicts(PackageObject* self) {
	char** deps = pakfire_package_get_conflicts(self->package);

	PyObject* list = PyList_FromRelationList(deps);

	if (deps) {
		for (char** dep = deps; *dep; dep++)
			free(*dep);
		free(deps);
	}

	return list;
}

static PyObject* Package_get_recommends(PackageObject* self) {
	char** deps = pakfire_package_get_recommends(self->package);

	PyObject* list = PyList_FromRelationList(deps);

	if (deps) {
		for (char** dep = deps; *dep; dep++)
			free(*dep);
		free(deps);
	}

	return list;
}

static PyObject* Package_get_suggests(PackageObject* self) {
	char** deps = pakfire_package_get_suggests(self->package);

	PyObject* list = PyList_FromRelationList(deps);

	if (deps) {
		for (char** dep = deps; *dep; dep++)
			free(*dep);
		free(deps);
	}

	return list;
}

static PyObject* Package_get_reverse_requires(PackageObject* self) {
	struct pakfire_packagelist* list = NULL;

	int r = pakfire_package_get_reverse_requires(self->package, &list);
	if (r) {
		PyErr_SetFromErrno(PyExc_OSError);
		return NULL;
	}

	PyObject* object = PyList_FromPackageList(list);
	pakfire_packagelist_unref(list);

	return object;
}

static PyObject* Package_get_filelist(PackageObject* self, PyObject* args) {
	PyObject* list = PyList_New(0);
	if (list == NULL)
		return NULL;

	struct pakfire_filelist* filelist = pakfire_package_get_filelist(self->package);
	for (unsigned int i = 0; i < pakfire_filelist_size(filelist); i++) {
		struct pakfire_file* file = pakfire_filelist_get(filelist, i);
		const char* path = pakfire_file_get_path(file);
		pakfire_file_unref(file);

		PyObject* obj = PyUnicode_FromString(path);

		int ret = PyList_Append(list, obj);
		Py_DECREF(obj);

		if (ret) {
			pakfire_filelist_unref(filelist);
			Py_DECREF(list);

			return NULL;
		}
	}

	pakfire_filelist_unref(filelist);

	return list;
}

static int Package_set_filelist(PackageObject* self, PyObject* value) {
	if (!PySequence_Check(value)) {
		PyErr_SetString(PyExc_AttributeError, "Expected a sequence.");
		return -1;
	}

	Pakfire pakfire = pakfire_package_get_pakfire(self->package);

	// Create a new filelist
	struct pakfire_filelist* filelist;

	int r = pakfire_filelist_create(&filelist, pakfire);
	if (r) {
		pakfire_unref(pakfire);
		errno = -r;
		PyErr_SetFromErrno(PyExc_OSError);

		return -1;
	}

	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);
			pakfire_filelist_unref(filelist);
			pakfire_unref(pakfire);

			PyErr_SetString(PyExc_AttributeError, "Expected a string");
			return -1;
		}

		const char* path = PyUnicode_AsUTF8(item);
		Py_DECREF(item);

		// Create a new file
		struct pakfire_file* file;

		r = pakfire_file_create(&file, pakfire);
		if (r) {
			errno = -r;
			PyErr_SetFromErrno(PyExc_OSError);
			pakfire_filelist_unref(filelist);
			pakfire_unref(pakfire);
			return -1;
		}

		// Set the path
		pakfire_file_set_path(file, path);

		// Append the file to the filelist
		pakfire_filelist_append(filelist, file);
		pakfire_file_unref(file);
	}

	// Set filelist
	r = pakfire_package_set_filelist(self->package, filelist);
	pakfire_filelist_unref(filelist);

	if (r) {
		pakfire_unref(pakfire);

		errno = -r;
		PyErr_SetFromErrno(PyExc_OSError);

		return -1;
	}

	pakfire_unref(pakfire);

	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[] = {
	{
		"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
	},
	{
		"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
	},

	// Dependencies
	{
		"provides",
		(getter)Package_get_provides,
		NULL,
		NULL,
		NULL
	},
	{
		"requires",
		(getter)Package_get_requires,
		NULL,
		NULL,
		NULL
	},
	{
		"obsoletes",
		(getter)Package_get_obsoletes,
		NULL,
		NULL,
		NULL
	},
	{
		"conflicts",
		(getter)Package_get_conflicts,
		NULL,
		NULL,
		NULL
	},
	{
		"recommends",
		(getter)Package_get_recommends,
		NULL,
		NULL,
		NULL
	},
	{
		"suggests",
		(getter)Package_get_suggests,
		NULL,
		NULL,
		NULL
	},
	{
		"reverse_requires",
		(getter)Package_get_reverse_requires,
		NULL,
		NULL,
		NULL
	},

	// Repository
	{
		"repo",
		(getter)Package_get_repo,
		NULL,
		NULL,
		NULL
	},
	{
		"path",
		(getter)Package_get_path,
		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_repr:            (reprfunc)Package_repr,
	tp_str:             (reprfunc)Package_str,
	tp_richcompare:     (richcmpfunc)Package_richcompare,
};