src/_pakfire/package.c

   1 /*#############################################################################
   2 #                                                                             #
   3 # Pakfire - The IPFire package management system                              #
   4 # Copyright (C) 2011 Pakfire development team                                 #
   5 #                                                                             #
   6 # This program is free software: you can redistribute it and/or modify        #
   7 # it under the terms of the GNU General Public License as published by        #
   8 # the Free Software Foundation, either version 3 of the License, or           #
   9 # (at your option) any later version.                                         #
  10 #                                                                             #
  11 # This program is distributed in the hope that it will be useful,             #
  12 # but WITHOUT ANY WARRANTY; without even the implied warranty of              #
  13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               #
  14 # GNU General Public License for more details.                                #
  15 #                                                                             #
  16 # You should have received a copy of the GNU General Public License           #
  17 # along with this program.  If not, see <http://www.gnu.org/licenses/>.       #
  18 #                                                                             #
  19 #############################################################################*/
  20
  21 #include <Python.h>
  22
  23 #include <pakfire/file.h>
  24 #include <pakfire/filelist.h>
  25 #include <pakfire/package.h>
  26 #include <pakfire/repo.h>
  27 #include <pakfire/util.h>
  28
  29 #include "package.h"
  30 #include "pakfire.h"
  31 #include "repo.h"
  32 #include "util.h"
  33
  34 PyObject* new_package(PyTypeObject* type, struct pakfire_package* pkg) {
  35         PackageObject* self = (PackageObject *)type->tp_alloc(type, 0);
  36         if (self) {
  37                 self->package = pakfire_package_ref(pkg);
  38         }
  39
  40         return (PyObject *)self;
  41 }
  42
  43 static PyObject* Package_new(PyTypeObject* type, PyObject* args, PyObject* kwds) {
  44         PackageObject* self = (PackageObject *)type->tp_alloc(type, 0);
  45         if (self) {
  46                 self->package = NULL;
  47         }
  48
  49         return (PyObject *)self;
  50 }
  51
  52 static void Package_dealloc(PackageObject* self) {
  53         pakfire_package_unref(self->package);
  54
  55         Py_TYPE(self)->tp_free((PyObject *)self);
  56 }
  57
  58 static int Package_init(PackageObject* self, PyObject* args, PyObject* kwds) {
  59         PakfireObject* pakfire;
  60         RepoObject* repo;
  61         const char* name = NULL;
  62         const char* evr = NULL;
  63         const char* arch = NULL;
  64
  65         if (!PyArg_ParseTuple(args, "O!O!sss", &PakfireType, &pakfire, &RepoType, &repo,
  66                         &name, &evr, &arch))
  67                 return -1;
  68
  69         self->package = pakfire_package_create(pakfire->pakfire, repo->repo, name, evr, arch);
  70         if (!self->package) {
  71                 PyErr_SetFromErrno(PyExc_OSError);
  72                 return -1;
  73         }
  74
  75         return 0;
  76 }
  77
  78 static PyObject* Package_repr(PackageObject* self) {
  79         const char* nevra = pakfire_package_get_nevra(self->package);
  80
  81         return PyUnicode_FromFormat("<_pakfire.Package %s>", nevra);
  82 }
  83
  84 static PyObject* Package_str(PackageObject* self) {
  85         const char* nevra = pakfire_package_get_nevra(self->package);
  86
  87         return PyUnicode_FromString(nevra);
  88 }
  89
  90 static PyObject* Package_richcompare(PackageObject* self, PyObject* _other, int op) {
  91         if (!PyType_IsSubtype(_other->ob_type, &PackageType)) {
  92                 PyErr_SetString(PyExc_TypeError, "Expected a Package object");
  93                 return NULL;
  94         }
  95
  96         PackageObject* other = (PackageObject *)_other;
  97
  98         long result = pakfire_package_cmp(self->package, other->package);
  99
 100         switch (op) {
 101                 case Py_EQ:
 102                         if (result == 0)
 103                                 Py_RETURN_TRUE;
 104                         break;
 105
 106                 case Py_NE:
 107                         if (result != 0)
 108                                 Py_RETURN_TRUE;
 109                         break;
 110
 111                 case Py_LE:
 112                         if (result <= 0)
 113                                 Py_RETURN_TRUE;
 114                         break;
 115
 116                 case Py_GE:
 117                         if (result >= 0)
 118                                 Py_RETURN_TRUE;
 119                         break;
 120
 121                 case Py_LT:
 122                         if (result < 0)
 123                                 Py_RETURN_TRUE;
 124                         break;
 125
 126                 case Py_GT:
 127                         if (result > 0)
 128                                 Py_RETURN_TRUE;
 129                         break;
 130
 131                 default:
 132                         PyErr_BadArgument();
 133                         return NULL;
 134         }
 135
 136         Py_RETURN_FALSE;
 137 }
 138
 139 static const char* PyUnicode_FromValue(PyObject* value) {
 140         if (value == Py_None)
 141                 return NULL;
 142
 143         return PyUnicode_AsUTF8(value);
 144 }
 145
 146 static PyObject* Package_get_name(PackageObject* self) {
 147         const char* name = pakfire_package_get_name(self->package);
 148         if (!name)
 149                 Py_RETURN_NONE;
 150
 151         return PyUnicode_FromString(name);
 152 }
 153
 154 static void Package_set_name(PackageObject* self, PyObject* value) {
 155         const char* name = PyUnicode_FromValue(value);
 156
 157         pakfire_package_set_name(self->package, name);
 158 }
 159
 160 static PyObject* Package_get_evr(PackageObject* self) {
 161         const char* evr = pakfire_package_get_evr(self->package);
 162         if (!evr)
 163                 Py_RETURN_NONE;
 164
 165         return PyUnicode_FromString(evr);
 166 }
 167
 168 static PyObject* Package_get_arch(PackageObject* self) {
 169         const char* arch = pakfire_package_get_arch(self->package);
 170         if (!arch)
 171                 Py_RETURN_NONE;
 172
 173         return PyUnicode_FromString(arch);
 174 }
 175
 176 static void Package_set_arch(PackageObject* self, PyObject* value) {
 177         const char* arch = PyUnicode_FromValue(value);
 178
 179         pakfire_package_set_arch(self->package, arch);
 180 }
 181
 182 static PyObject* Package_get_uuid(PackageObject* self) {
 183         const char* uuid = pakfire_package_get_uuid(self->package);
 184         if (!uuid)
 185                 Py_RETURN_NONE;
 186
 187         return PyUnicode_FromString(uuid);
 188 }
 189
 190 static void Package_set_uuid(PackageObject* self, PyObject* value) {
 191         const char* uuid = PyUnicode_FromValue(value);
 192
 193         pakfire_package_set_uuid(self->package, uuid);
 194 }
 195
 196 static PyObject* Package_get_checksum(PackageObject* self) {
 197         const char* checksum = pakfire_package_get_checksum(self->package);
 198         if (!checksum)
 199                 Py_RETURN_NONE;
 200
 201         return PyUnicode_FromString(checksum);
 202 }
 203
 204 static void Package_set_checksum(PackageObject* self, PyObject* value) {
 205         const char* checksum = PyUnicode_FromValue(value);
 206
 207         pakfire_package_set_checksum(self->package, checksum);
 208 }
 209
 210 static PyObject* Package_get_summary(PackageObject* self) {
 211         const char* summary = pakfire_package_get_summary(self->package);
 212         if (!summary)
 213                 Py_RETURN_NONE;
 214
 215         return PyUnicode_FromString(summary);
 216 }
 217
 218 static void Package_set_summary(PackageObject* self, PyObject* value) {
 219         const char* summary = PyUnicode_FromValue(value);
 220
 221         pakfire_package_set_summary(self->package, summary);
 222 }
 223
 224 static PyObject* Package_get_description(PackageObject* self) {
 225         const char* description = pakfire_package_get_description(self->package);
 226         if (!description)
 227                 Py_RETURN_NONE;
 228
 229         return PyUnicode_FromString(description);
 230 }
 231
 232 static void Package_set_description(PackageObject* self, PyObject* value) {
 233         const char* description = PyUnicode_FromValue(value);
 234
 235         pakfire_package_set_description(self->package, description);
 236 }
 237
 238 static PyObject* Package_get_license(PackageObject* self) {
 239         const char* license = pakfire_package_get_license(self->package);
 240         if (!license)
 241                 Py_RETURN_NONE;
 242
 243         return PyUnicode_FromString(license);
 244 }
 245
 246 static void Package_set_license(PackageObject* self, PyObject* value) {
 247         const char* license = PyUnicode_FromValue(value);
 248
 249         pakfire_package_set_summary(self->package, license);
 250 }
 251
 252 static PyObject* Package_get_url(PackageObject* self) {
 253         const char* url = pakfire_package_get_url(self->package);
 254         if (!url)
 255                 Py_RETURN_NONE;
 256
 257         return PyUnicode_FromString(url);
 258 }
 259
 260 static void Package_set_url(PackageObject* self, PyObject* value) {
 261         const char* url = PyUnicode_FromValue(value);
 262
 263         pakfire_package_set_url(self->package, url);
 264 }
 265
 266 static PyObject* Package_get_groups(PackageObject* self) {
 267         const char* s = pakfire_package_get_groups(self->package);
 268
 269         return PyUnicode_FromString(s);
 270 }
 271
 272 static int Package_set_groups(PackageObject* self, PyObject* value) {
 273         const char* groups = PyUnicode_AsUTF8(value);
 274
 275         if (groups)
 276                 pakfire_package_set_groups(self->package, groups);
 277
 278         return 0;
 279 }
 280
 281 static PyObject* Package_get_vendor(PackageObject* self) {
 282         const char* vendor = pakfire_package_get_vendor(self->package);
 283         if (!vendor)
 284                 Py_RETURN_NONE;
 285
 286         return PyUnicode_FromString(vendor);
 287 }
 288
 289 static void Package_set_vendor(PackageObject* self, PyObject* value) {
 290         const char* vendor = PyUnicode_FromValue(value);
 291
 292         pakfire_package_set_vendor(self->package, vendor);
 293 }
 294
 295 static PyObject* Package_get_maintainer(PackageObject* self) {
 296         const char* maintainer = pakfire_package_get_maintainer(self->package);
 297         if (!maintainer)
 298                 Py_RETURN_NONE;
 299
 300         return PyUnicode_FromString(maintainer);
 301 }
 302
 303 static void Package_set_maintainer(PackageObject* self, PyObject* value) {
 304         const char* maintainer = PyUnicode_FromValue(value);
 305
 306         pakfire_package_set_maintainer(self->package, maintainer);
 307 }
 308
 309 static PyObject* Package_get_filename(PackageObject* self) {
 310         const char* filename = pakfire_package_get_filename(self->package);
 311         if (!filename)
 312                 Py_RETURN_NONE;
 313
 314         return PyUnicode_FromString(filename);
 315 }
 316
 317 static void Package_set_filename(PackageObject* self, PyObject* value) {
 318         const char* filename = PyUnicode_FromValue(value);
 319
 320         pakfire_package_set_filename(self->package, filename);
 321 }
 322
 323 static PyObject* Package_get_installed(PackageObject* self) {
 324         int installed = pakfire_package_is_installed(self->package);
 325
 326         return PyBool_FromLong(installed);
 327 }
 328
 329 static PyObject* Package_get_downloadsize(PackageObject* self) {
 330         unsigned long long size = pakfire_package_get_downloadsize(self->package);
 331
 332         return PyLong_FromUnsignedLongLong(size);
 333 }
 334
 335 static void Package_set_downloadsize(PackageObject* self, PyObject* value) {
 336         unsigned long downloadsize = PyLong_AsUnsignedLong(value);
 337
 338         pakfire_package_set_downloadsize(self->package, downloadsize);
 339 }
 340
 341 static PyObject* Package_get_installsize(PackageObject* self) {
 342         unsigned long long size = pakfire_package_get_installsize(self->package);
 343
 344         return PyLong_FromUnsignedLongLong(size);
 345 }
 346
 347 static void Package_set_installsize(PackageObject* self, PyObject* value) {
 348         unsigned long installsize = PyLong_AsUnsignedLong(value);
 349
 350         pakfire_package_set_installsize(self->package, installsize);
 351 }
 352
 353 static PyObject* Package_get_size(PackageObject* self) {
 354         unsigned long long size = pakfire_package_get_size(self->package);
 355
 356         return PyLong_FromUnsignedLongLong(size);
 357 }
 358
 359 static PyObject* Package_get_buildhost(PackageObject* self) {
 360         const char* build_host = pakfire_package_get_build_host(self->package);
 361         if (!build_host)
 362                 Py_RETURN_NONE;
 363
 364         return PyUnicode_FromString(build_host);
 365 }
 366
 367 static void Package_set_buildhost(PackageObject* self, PyObject* value) {
 368         const char* build_host = PyUnicode_FromValue(value);
 369
 370         pakfire_package_set_build_host(self->package, build_host);
 371 }
 372
 373 static PyObject* Package_get_buildtime(PackageObject* self) {
 374         time_t build_time = pakfire_package_get_build_time(self->package);
 375
 376         return PyLong_FromUnsignedLongLong(build_time);
 377 }
 378
 379 static void Package_set_buildtime(PackageObject* self, PyObject* value) {
 380         time_t build_time = PyLong_AsUnsignedLongLong(value);
 381
 382         pakfire_package_set_build_time(self->package, build_time);
 383 }
 384
 385 static PyObject* Package_get_repo(PackageObject* self) {
 386         struct pakfire_repo* repo = pakfire_package_get_repo(self->package);
 387         if (!repo)
 388                 Py_RETURN_NONE;
 389
 390         PyObject* obj = new_repo(&RepoType, repo);
 391         pakfire_repo_unref(repo);
 392
 393         return obj;
 394 }
 395
 396 static PyObject* Package_get_path(PackageObject* self) {
 397         const char* path = pakfire_package_get_path(self->package);
 398         if (!path) {
 399                 PyErr_SetFromErrno(PyExc_OSError);
 400                 return NULL;
 401         }
 402
 403         return PyUnicode_FromString(path);
 404 }
 405
 406 static PyObject* PyList_FromRelationList(char** deps) {
 407         PyObject* list = PyList_New(0);
 408         if (list == NULL)
 409                 return NULL;
 410
 411         // Empty list?
 412         if (!deps)
 413                 return list;
 414
 415         for (char** dep = deps; *dep; dep++) {
 416                 PyObject* obj = PyUnicode_FromString(*dep);
 417                 if (!obj)
 418                         break;
 419
 420                 PyList_Append(list, obj);
 421                 Py_DECREF(obj);
 422         }
 423
 424         return list;
 425 }
 426
 427 static PyObject* Package_get_provides(PackageObject* self) {
 428         char** deps = pakfire_package_get_provides(self->package);
 429
 430         PyObject* list = PyList_FromRelationList(deps);
 431
 432         if (deps) {
 433                 for (char** dep = deps; *dep; dep++)
 434                         free(*dep);
 435                 free(deps);
 436         }
 437
 438         return list;
 439 }
 440
 441 static PyObject* Package_get_requires(PackageObject* self) {
 442         char** deps = pakfire_package_get_requires(self->package);
 443
 444         PyObject* list = PyList_FromRelationList(deps);
 445
 446         if (deps) {
 447                 for (char** dep = deps; *dep; dep++)
 448                         free(*dep);
 449                 free(deps);
 450         }
 451
 452         return list;
 453 }
 454
 455 static PyObject* Package_get_obsoletes(PackageObject* self) {
 456         char** deps = pakfire_package_get_obsoletes(self->package);
 457
 458         PyObject* list = PyList_FromRelationList(deps);
 459
 460         if (deps) {
 461                 for (char** dep = deps; *dep; dep++)
 462                         free(*dep);
 463                 free(deps);
 464         }
 465
 466         return list;
 467 }
 468
 469 static PyObject* Package_get_conflicts(PackageObject* self) {
 470         char** deps = pakfire_package_get_conflicts(self->package);
 471
 472         PyObject* list = PyList_FromRelationList(deps);
 473
 474         if (deps) {
 475                 for (char** dep = deps; *dep; dep++)
 476                         free(*dep);
 477                 free(deps);
 478         }
 479
 480         return list;
 481 }
 482
 483 static PyObject* Package_get_recommends(PackageObject* self) {
 484         char** deps = pakfire_package_get_recommends(self->package);
 485
 486         PyObject* list = PyList_FromRelationList(deps);
 487
 488         if (deps) {
 489                 for (char** dep = deps; *dep; dep++)
 490                         free(*dep);
 491                 free(deps);
 492         }
 493
 494         return list;
 495 }
 496
 497 static PyObject* Package_get_suggests(PackageObject* self) {
 498         char** deps = pakfire_package_get_suggests(self->package);
 499
 500         PyObject* list = PyList_FromRelationList(deps);
 501
 502         if (deps) {
 503                 for (char** dep = deps; *dep; dep++)
 504                         free(*dep);
 505                 free(deps);
 506         }
 507
 508         return list;
 509 }
 510
 511 static PyObject* Package_get_reverse_requires(PackageObject* self) {
 512         struct pakfire_packagelist* list = NULL;
 513
 514         int r = pakfire_package_get_reverse_requires(self->package, &list);
 515         if (r) {
 516                 PyErr_SetFromErrno(PyExc_OSError);
 517                 return NULL;
 518         }
 519
 520         PyObject* object = PyList_FromPackageList(list);
 521         pakfire_packagelist_unref(list);
 522
 523         return object;
 524 }
 525
 526 static PyObject* Package_get_filelist(PackageObject* self, PyObject* args) {
 527         PyObject* list = PyList_New(0);
 528         if (list == NULL)
 529                 return NULL;
 530
 531         struct pakfire_filelist* filelist = pakfire_package_get_filelist(self->package);
 532         for (unsigned int i = 0; i < pakfire_filelist_size(filelist); i++) {
 533                 struct pakfire_file* file = pakfire_filelist_get(filelist, i);
 534                 const char* path = pakfire_file_get_path(file);
 535                 pakfire_file_unref(file);
 536
 537                 PyObject* obj = PyUnicode_FromString(path);
 538
 539                 int ret = PyList_Append(list, obj);
 540                 Py_DECREF(obj);
 541
 542                 if (ret) {
 543                         pakfire_filelist_unref(filelist);
 544                         Py_DECREF(list);
 545
 546                         return NULL;
 547                 }
 548         }
 549
 550         pakfire_filelist_unref(filelist);
 551
 552         return list;
 553 }
 554
 555 static int Package_set_filelist(PackageObject* self, PyObject* value) {
 556         if (!PySequence_Check(value)) {
 557                 PyErr_SetString(PyExc_AttributeError, "Expected a sequence.");
 558                 return -1;
 559         }
 560
 561         Pakfire pakfire = pakfire_package_get_pakfire(self->package);
 562
 563         // Create a new filelist
 564         struct pakfire_filelist* filelist;
 565
 566         int r = pakfire_filelist_create(&filelist, pakfire);
 567         if (r) {
 568                 pakfire_unref(pakfire);
 569                 errno = -r;
 570                 PyErr_SetFromErrno(PyExc_OSError);
 571
 572                 return -1;
 573         }
 574
 575         const int length = PySequence_Length(value);
 576         for (int i = 0; i < length; i++) {
 577                 PyObject* item = PySequence_GetItem(value, i);
 578
 579                 if (!PyUnicode_Check(item)) {
 580                         Py_DECREF(item);
 581                         pakfire_filelist_unref(filelist);
 582                         pakfire_unref(pakfire);
 583
 584                         PyErr_SetString(PyExc_AttributeError, "Expected a string");
 585                         return -1;
 586                 }
 587
 588                 const char* path = PyUnicode_AsUTF8(item);
 589                 Py_DECREF(item);
 590
 591                 // Create a new file
 592                 struct pakfire_file* file;
 593
 594                 r = pakfire_file_create(&file, pakfire);
 595                 if (r) {
 596                         errno = -r;
 597                         PyErr_SetFromErrno(PyExc_OSError);
 598                         pakfire_filelist_unref(filelist);
 599                         pakfire_unref(pakfire);
 600                         return -1;
 601                 }
 602
 603                 // Set the path
 604                 pakfire_file_set_path(file, path);
 605
 606                 // Append the file to the filelist
 607                 pakfire_filelist_append(filelist, file);
 608                 pakfire_file_unref(file);
 609         }
 610
 611         // Set filelist
 612         r = pakfire_package_set_filelist(self->package, filelist);
 613         pakfire_filelist_unref(filelist);
 614
 615         if (r) {
 616                 pakfire_unref(pakfire);
 617
 618                 errno = -r;
 619                 PyErr_SetFromErrno(PyExc_OSError);
 620
 621                 return -1;
 622         }
 623
 624         pakfire_unref(pakfire);
 625
 626         return 0;
 627 }
 628
 629 static PyObject* Package_dump(PackageObject* self, PyObject *args, PyObject* kwds) {
 630         static char* kwlist[] = {"long", "filelist", NULL};
 631
 632         int long_format = 0;
 633         int filelist = 0;
 634
 635         if (!PyArg_ParseTupleAndKeywords(args, kwds, "|ii", kwlist, &long_format, &filelist))
 636                 return NULL;
 637
 638         int flags = 0;
 639         if (long_format)
 640                 flags |= PAKFIRE_PKG_DUMP_LONG;
 641
 642         if (filelist)
 643                 flags |= PAKFIRE_PKG_DUMP_FILELIST;
 644
 645         char* package_dump = pakfire_package_dump(self->package, flags);
 646
 647         if (!package_dump)
 648                 Py_RETURN_NONE;
 649
 650         return PyUnicode_FromString(package_dump);
 651 }
 652
 653 static struct PyMethodDef Package_methods[] = {
 654         {
 655                 "dump",
 656                 (PyCFunction)Package_dump,
 657                 METH_VARARGS|METH_KEYWORDS,
 658                 NULL
 659         },
 660         { NULL },
 661 };
 662
 663 static struct PyGetSetDef Package_getsetters[] = {
 664         {
 665                 "name",
 666                 (getter)Package_get_name,
 667                 (setter)Package_set_name,
 668                 NULL,
 669                 NULL
 670         },
 671         {
 672                 "evr",
 673                 (getter)Package_get_evr,
 674                 NULL,
 675                 NULL,
 676                 NULL
 677         },
 678         {
 679                 "arch",
 680                 (getter)Package_get_arch,
 681                 (setter)Package_set_arch,
 682                 NULL,
 683                 NULL
 684         },
 685         {
 686                 "uuid",
 687                 (getter)Package_get_uuid,
 688                 (setter)Package_set_uuid,
 689                 NULL,
 690                 NULL
 691         },
 692         {
 693                 "checksum",
 694                 (getter)Package_get_checksum,
 695                 (setter)Package_set_checksum,
 696                 NULL,
 697                 NULL
 698         },
 699         {
 700                 "summary",
 701                 (getter)Package_get_summary,
 702                 (setter)Package_set_summary,
 703                 NULL,
 704                 NULL
 705         },
 706         {
 707                 "description",
 708                 (getter)Package_get_description,
 709                 (setter)Package_set_description,
 710                 NULL,
 711                 NULL
 712         },
 713         {
 714                 "license",
 715                 (getter)Package_get_license,
 716                 (setter)Package_set_license,
 717                 NULL,
 718                 NULL
 719         },
 720         {
 721                 "url",
 722                 (getter)Package_get_url,
 723                 (setter)Package_set_url,
 724                 NULL,
 725                 NULL
 726         },
 727         {
 728                 "groups",
 729                 (getter)Package_get_groups,
 730                 (setter)Package_set_groups,
 731                 NULL,
 732                 NULL
 733         },
 734         {
 735                 "vendor",
 736                 (getter)Package_get_vendor,
 737                 (setter)Package_set_vendor,
 738                 NULL,
 739                 NULL
 740         },
 741         {
 742                 "maintainer",
 743                 (getter)Package_get_maintainer,
 744                 (setter)Package_set_maintainer,
 745                 NULL,
 746                 NULL
 747         },
 748         {
 749                 "filename",
 750                 (getter)Package_get_filename,
 751                 (setter)Package_set_filename,
 752                 NULL,
 753                 NULL
 754         },
 755         {
 756                 "installed",
 757                 (getter)Package_get_installed,
 758                 NULL,
 759                 NULL,
 760                 NULL
 761         },
 762         {
 763                 "downloadsize",
 764                 (getter)Package_get_downloadsize,
 765                 (setter)Package_set_downloadsize,
 766                 NULL,
 767                 NULL
 768         },
 769         {
 770                 "installsize",
 771                 (getter)Package_get_installsize,
 772                 (setter)Package_set_installsize,
 773                 NULL,
 774                 NULL
 775         },
 776         {
 777                 "size",
 778                 (getter)Package_get_size,
 779                 NULL,
 780                 NULL,
 781                 NULL
 782         },
 783         {
 784                 "buildhost",
 785                 (getter)Package_get_buildhost,
 786                 (setter)Package_set_buildhost,
 787                 NULL,
 788                 NULL
 789         },
 790         {
 791                 "buildtime",
 792                 (getter)Package_get_buildtime,
 793                 (setter)Package_set_buildtime,
 794                 NULL,
 795                 NULL
 796         },
 797
 798         // Dependencies
 799         {
 800                 "provides",
 801                 (getter)Package_get_provides,
 802                 NULL,
 803                 NULL,
 804                 NULL
 805         },
 806         {
 807                 "requires",
 808                 (getter)Package_get_requires,
 809                 NULL,
 810                 NULL,
 811                 NULL
 812         },
 813         {
 814                 "obsoletes",
 815                 (getter)Package_get_obsoletes,
 816                 NULL,
 817                 NULL,
 818                 NULL
 819         },
 820         {
 821                 "conflicts",
 822                 (getter)Package_get_conflicts,
 823                 NULL,
 824                 NULL,
 825                 NULL
 826         },
 827         {
 828                 "recommends",
 829                 (getter)Package_get_recommends,
 830                 NULL,
 831                 NULL,
 832                 NULL
 833         },
 834         {
 835                 "suggests",
 836                 (getter)Package_get_suggests,
 837                 NULL,
 838                 NULL,
 839                 NULL
 840         },
 841         {
 842                 "reverse_requires",
 843                 (getter)Package_get_reverse_requires,
 844                 NULL,
 845                 NULL,
 846                 NULL
 847         },
 848
 849         // Repository
 850         {
 851                 "repo",
 852                 (getter)Package_get_repo,
 853                 NULL,
 854                 NULL,
 855                 NULL
 856         },
 857         {
 858                 "path",
 859                 (getter)Package_get_path,
 860                 NULL,
 861                 NULL,
 862                 NULL
 863         },
 864
 865         // Filelist
 866         {
 867                 "filelist",
 868                 (getter)Package_get_filelist,
 869                 (setter)Package_set_filelist,
 870                 NULL,
 871                 NULL
 872         },
 873
 874         { NULL }
 875 };
 876
 877 PyTypeObject PackageType = {
 878         PyVarObject_HEAD_INIT(NULL, 0)
 879         tp_name:            "_pakfire.Package",
 880         tp_basicsize:       sizeof(PackageObject),
 881         tp_flags:           Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
 882         tp_new:             Package_new,
 883         tp_dealloc:         (destructor)Package_dealloc,
 884         tp_init:            (initproc)Package_init,
 885         tp_doc:             "Package object",
 886         tp_methods:         Package_methods,
 887         tp_getset:          Package_getsetters,
 888         tp_repr:            (reprfunc)Package_repr,
 889         tp_str:             (reprfunc)Package_str,
 890         tp_richcompare:     (richcmpfunc)Package_richcompare,
 891 };