python/src/solvable.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 "config.h"
  24 #include "relation.h"
  25 #include "repo.h"
  26 #include "solvable.h"
  27
  28 PyTypeObject SolvableType = {
  29         PyObject_HEAD_INIT(NULL)
  30         tp_name: "_pakfire.Solvable",
  31         tp_basicsize: sizeof(SolvableObject),
  32         tp_flags: Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
  33         tp_new : Solvable_new,
  34         tp_dealloc: (destructor) Solvable_dealloc,
  35         tp_doc: "Sat Solvable objects",
  36         tp_str: (reprfunc)Solvable_string,
  37 };
  38
  39 // Solvable
  40 PyObject* Solvable_new(PyTypeObject *type, PyObject *args, PyObject *kwds) {
  41         SolvableObject *self;
  42
  43         RepoObject *repo;
  44         const char *name;
  45         const char *evr;
  46         const char *arch = "noarch";
  47
  48         if (!PyArg_ParseTuple(args, "Oss|s", &repo, &name, &evr, &arch)) {
  49                 /* XXX raise exception */
  50                 return NULL;
  51         }
  52
  53         self = (SolvableObject *)type->tp_alloc(type, 0);
  54         if (self != NULL) {
  55                 self->_id = repo_add_solvable(repo->_repo);
  56                 self->_pool = repo->_repo->pool;
  57
  58                 /* Fill solvable with data. */
  59                 Solvable *solv = pool_id2solvable(self->_pool, self->_id);
  60
  61                 solv->name = pool_str2id(self->_pool, name, 1);
  62                 solv->evr = pool_str2id(self->_pool, evr, 1);
  63                 solv->arch = pool_str2id(self->_pool, arch, 1);
  64
  65                 /* add self-provides */
  66                 Id rel = pool_rel2id(self->_pool, solv->name, solv->evr, REL_EQ, 1);
  67                 solv->provides = repo_addid_dep(repo->_repo, solv->provides, rel, 0);
  68         }
  69
  70         return (PyObject *)self;
  71 }
  72
  73 PyObject *Solvable_dealloc(SolvableObject *self) {
  74         self->ob_type->tp_free((PyObject *)self);
  75
  76         Py_RETURN_NONE;
  77 }
  78
  79 PyObject *Solvable_string(SolvableObject *self) {
  80         Solvable *solvable = pool_id2solvable(self->_pool, self->_id);
  81
  82         const char *str = pool_solvable2str(self->_pool, solvable);
  83
  84         return Py_BuildValue("s", str);
  85 }
  86
  87 PyObject *Solvable_get_name(SolvableObject *self) {
  88         Solvable *solvable = pool_id2solvable(self->_pool, self->_id);
  89
  90         const char *name = pool_id2str(solvable->repo->pool, solvable->name);
  91
  92         return Py_BuildValue("s", name);
  93 }
  94
  95 PyObject *Solvable_get_evr(SolvableObject *self) {
  96         Solvable *solvable = pool_id2solvable(self->_pool, self->_id);
  97
  98         const char *evr = pool_id2str(solvable->repo->pool, solvable->evr);
  99
 100         return Py_BuildValue("s", evr);
 101 }
 102
 103 PyObject *Solvable_get_arch(SolvableObject *self) {
 104         Solvable *solvable = pool_id2solvable(self->_pool, self->_id);
 105
 106         const char *arch = pool_id2str(solvable->repo->pool, solvable->arch);
 107
 108         return Py_BuildValue("s", arch);
 109 }
 110
 111 PyObject *Solvable_get_vendor(SolvableObject *self) {
 112         Solvable *solvable = pool_id2solvable(self->_pool, self->_id);
 113
 114         const char *vendor = pool_id2str(solvable->repo->pool, solvable->vendor);
 115
 116         return Py_BuildValue("s", vendor);
 117 }
 118
 119 PyObject *Solvable_set_vendor(SolvableObject *self, PyObject *args) {
 120         Solvable *solvable = pool_id2solvable(self->_pool, self->_id);
 121
 122         const char *vendor;
 123         if (!PyArg_ParseTuple(args, "s", &vendor)) {
 124                 /* XXX raise exception */
 125                 return NULL;
 126         }
 127
 128         solvable->vendor = pool_str2id(self->_pool, vendor, 1);
 129
 130         Py_RETURN_NONE;
 131 }
 132
 133 PyObject *Solvable_get_repo_name(SolvableObject *self) {
 134         Solvable *solvable = pool_id2solvable(self->_pool, self->_id);
 135
 136         return Py_BuildValue("s", solvable->repo->name);
 137 }
 138
 139 PyObject *Solvable_add_provides(SolvableObject *self, PyObject *args) {
 140         Solvable *solv = pool_id2solvable(self->_pool, self->_id);
 141
 142         RelationObject *rel;
 143         if (!PyArg_ParseTuple(args, "O", &rel)) {
 144                 /* XXX raise exception */
 145                 return NULL;
 146         }
 147
 148         solv->provides = repo_addid_dep(solv->repo, solv->provides, rel->_id, 0);
 149
 150         Py_RETURN_NONE;
 151 }
 152
 153 PyObject *_Solvable_get_dependencies(Solvable *solv, Offset deps) {
 154         Repo *repo = solv->repo;
 155         Pool *pool = repo->pool;
 156
 157         Id id, *ids;
 158         const char *dep_str;
 159
 160         PyObject *list = PyList_New(0);
 161
 162         ids = repo->idarraydata + deps;
 163         while((id = *ids++) != 0) {
 164                 dep_str = pool_dep2str(pool, id);
 165
 166                 // Do not include the filelist.
 167                 if (strcmp(dep_str, "solvable:filemarker") == 0)
 168                         break;
 169
 170                 PyList_Append(list, Py_BuildValue("s", dep_str));
 171         }
 172
 173         return list;
 174 }
 175
 176 PyObject *Solvable_get_provides(SolvableObject *self) {
 177         Solvable *solv = pool_id2solvable(self->_pool, self->_id);
 178
 179         return _Solvable_get_dependencies(solv, solv->provides);
 180 }
 181
 182 PyObject *Solvable_add_requires(SolvableObject *self, PyObject *args) {
 183         Solvable *solv = pool_id2solvable(self->_pool, self->_id);
 184
 185         RelationObject *rel;
 186         if (!PyArg_ParseTuple(args, "O", &rel)) {
 187                 /* XXX raise exception */
 188                 return NULL;
 189         }
 190
 191         solv->requires = repo_addid_dep(solv->repo, solv->requires, rel->_id, 0);
 192
 193         Py_RETURN_NONE;
 194 }
 195
 196 PyObject *Solvable_get_requires(SolvableObject *self) {
 197         Solvable *solv = pool_id2solvable(self->_pool, self->_id);
 198
 199         return _Solvable_get_dependencies(solv, solv->requires);
 200 }
 201
 202 PyObject *Solvable_add_obsoletes(SolvableObject *self, PyObject *args) {
 203         Solvable *solv = pool_id2solvable(self->_pool, self->_id);
 204
 205         RelationObject *rel;
 206         if (!PyArg_ParseTuple(args, "O", &rel)) {
 207                 /* XXX raise exception */
 208                 return NULL;
 209         }
 210
 211         solv->obsoletes = repo_addid_dep(solv->repo, solv->obsoletes, rel->_id, 0);
 212
 213         Py_RETURN_NONE;
 214 }
 215
 216 PyObject *Solvable_get_obsoletes(SolvableObject *self) {
 217         Solvable *solv = pool_id2solvable(self->_pool, self->_id);
 218
 219         return _Solvable_get_dependencies(solv, solv->obsoletes);
 220 }
 221
 222 PyObject *Solvable_add_conflicts(SolvableObject *self, PyObject *args) {
 223         Solvable *solv = pool_id2solvable(self->_pool, self->_id);
 224
 225         RelationObject *rel;
 226         if (!PyArg_ParseTuple(args, "O", &rel)) {
 227                 /* XXX raise exception */
 228                 return NULL;
 229         }
 230
 231         solv->conflicts = repo_addid_dep(solv->repo, solv->conflicts, rel->_id, 0);
 232
 233         Py_RETURN_NONE;
 234 }
 235
 236 PyObject *Solvable_get_conflicts(SolvableObject *self) {
 237         Solvable *solv = pool_id2solvable(self->_pool, self->_id);
 238
 239         return _Solvable_get_dependencies(solv, solv->conflicts);
 240 }
 241
 242 PyObject *Solvable_add_recommends(SolvableObject *self, PyObject *args) {
 243         Solvable *solv = pool_id2solvable(self->_pool, self->_id);
 244
 245         RelationObject *rel;
 246         if (!PyArg_ParseTuple(args, "O", &rel)) {
 247                 return NULL;
 248         }
 249
 250         solv->recommends = repo_addid_dep(solv->repo, solv->recommends, rel->_id, 0);
 251         Py_RETURN_NONE;
 252 }
 253
 254 PyObject *Solvable_get_recommends(SolvableObject *self) {
 255         Solvable *solv = pool_id2solvable(self->_pool, self->_id);
 256
 257         return _Solvable_get_dependencies(solv, solv->recommends);
 258 }
 259
 260 PyObject *Solvable_add_suggests(SolvableObject *self, PyObject *args) {
 261         Solvable *solv = pool_id2solvable(self->_pool, self->_id);
 262
 263         RelationObject *rel;
 264         if (!PyArg_ParseTuple(args, "O", &rel)) {
 265                 return NULL;
 266         }
 267
 268         solv->suggests = repo_addid_dep(solv->repo, solv->suggests, rel->_id, 0);
 269         Py_RETURN_NONE;
 270 }
 271
 272 PyObject *Solvable_get_suggests(SolvableObject *self) {
 273         Solvable *solv = pool_id2solvable(self->_pool, self->_id);
 274
 275         return _Solvable_get_dependencies(solv, solv->suggests);
 276 }
 277
 278 PyObject *Solvable_set_uuid(SolvableObject *self, PyObject *args) {
 279         Solvable *solv = pool_id2solvable(self->_pool, self->_id);
 280
 281         const char *uuid;
 282
 283         if (!PyArg_ParseTuple(args, "s", &uuid)) {
 284                 /* XXX raise exception */
 285                 return NULL;
 286         }
 287
 288         repo_set_str(solv->repo, self->_id, SOLVABLE_PKGID, uuid);
 289
 290         Py_RETURN_NONE;
 291 }
 292
 293 PyObject *Solvable_get_uuid(SolvableObject *self) {
 294         Solvable *solv = pool_id2solvable(self->_pool, self->_id);
 295
 296         const char *uuid = repo_lookup_str(solv->repo, self->_id, SOLVABLE_PKGID);
 297
 298         return Py_BuildValue("s", uuid);
 299 }
 300
 301 PyObject *Solvable_set_hash1(SolvableObject *self, PyObject *args) {
 302         Solvable *solv = pool_id2solvable(self->_pool, self->_id);
 303
 304         const char *hash1;
 305
 306         if (!PyArg_ParseTuple(args, "s", &hash1)) {
 307                 /* XXX raise exception */
 308                 return NULL;
 309         }
 310
 311         repo_set_str(solv->repo, self->_id, SOLVABLE_CHECKSUM, hash1);
 312
 313         Py_RETURN_NONE;
 314 }
 315
 316 PyObject *Solvable_get_hash1(SolvableObject *self) {
 317         Solvable *solv = pool_id2solvable(self->_pool, self->_id);
 318
 319         const char *hash1 = repo_lookup_str(solv->repo, self->_id, SOLVABLE_CHECKSUM);
 320
 321         return Py_BuildValue("s", hash1);
 322 }
 323
 324 PyObject *Solvable_set_summary(SolvableObject *self, PyObject *args) {
 325         Solvable *solv = pool_id2solvable(self->_pool, self->_id);
 326
 327         const char *summary;
 328
 329         if (!PyArg_ParseTuple(args, "s", &summary)) {
 330                 /* XXX raise exception */
 331                 return NULL;
 332         }
 333
 334         repo_set_str(solv->repo, self->_id, SOLVABLE_SUMMARY, summary);
 335
 336         Py_RETURN_NONE;
 337 }
 338
 339 PyObject *Solvable_get_summary(SolvableObject *self) {
 340         Solvable *solv = pool_id2solvable(self->_pool, self->_id);
 341
 342         const char *summary = repo_lookup_str(solv->repo, self->_id, SOLVABLE_SUMMARY);
 343
 344         return Py_BuildValue("s", summary);
 345 }
 346
 347 PyObject *Solvable_set_description(SolvableObject *self, PyObject *args) {
 348         Solvable *solv = pool_id2solvable(self->_pool, self->_id);
 349
 350         const char *desc;
 351
 352         if (!PyArg_ParseTuple(args, "s", &desc)) {
 353                 /* XXX raise exception */
 354                 return NULL;
 355         }
 356
 357         repo_set_str(solv->repo, self->_id, SOLVABLE_DESCRIPTION, desc);
 358
 359         Py_RETURN_NONE;
 360 }
 361
 362 PyObject *Solvable_get_description(SolvableObject *self) {
 363         Solvable *solv = pool_id2solvable(self->_pool, self->_id);
 364
 365         const char *desc = repo_lookup_str(solv->repo, self->_id,
 366                 SOLVABLE_DESCRIPTION);
 367
 368         return Py_BuildValue("s", desc);
 369 }
 370
 371 PyObject *Solvable_set_url(SolvableObject *self, PyObject *args) {
 372         Solvable *solv = pool_id2solvable(self->_pool, self->_id);
 373
 374         const char *url;
 375
 376         if (!PyArg_ParseTuple(args, "s", &url)) {
 377                 /* XXX raise exception */
 378                 return NULL;
 379         }
 380
 381         repo_set_str(solv->repo, self->_id, SOLVABLE_URL, url);
 382
 383         Py_RETURN_NONE;
 384 }
 385
 386 PyObject *Solvable_get_url(SolvableObject *self) {
 387         Solvable *solv = pool_id2solvable(self->_pool, self->_id);
 388
 389         const char *url = repo_lookup_str(solv->repo, self->_id, SOLVABLE_URL);
 390
 391         return Py_BuildValue("s", url);
 392 }
 393
 394 PyObject *Solvable_set_groups(SolvableObject *self, PyObject *args) {
 395         Solvable *solv = pool_id2solvable(self->_pool, self->_id);
 396
 397         const char *groups;
 398
 399         if (!PyArg_ParseTuple(args, "s", &groups)) {
 400                 /* XXX raise exception */
 401                 return NULL;
 402         }
 403
 404         repo_set_str(solv->repo, self->_id, SOLVABLE_GROUP, groups);
 405
 406         Py_RETURN_NONE;
 407 }
 408
 409 PyObject *Solvable_get_groups(SolvableObject *self) {
 410         Solvable *solv = pool_id2solvable(self->_pool, self->_id);
 411
 412         const char *groups = repo_lookup_str(solv->repo, self->_id, SOLVABLE_GROUP);
 413
 414         return Py_BuildValue("s", groups);
 415 }
 416
 417 PyObject *Solvable_set_filename(SolvableObject *self, PyObject *args) {
 418         Solvable *solv = pool_id2solvable(self->_pool, self->_id);
 419
 420         const char *filename;
 421
 422         if (!PyArg_ParseTuple(args, "s", &filename)) {
 423                 /* XXX raise exception */
 424                 return NULL;
 425         }
 426
 427         repo_set_str(solv->repo, self->_id, SOLVABLE_MEDIAFILE, filename);
 428
 429         Py_RETURN_NONE;
 430 }
 431
 432 PyObject *Solvable_get_filename(SolvableObject *self) {
 433         Solvable *solv = pool_id2solvable(self->_pool, self->_id);
 434
 435         const char *filename = repo_lookup_str(solv->repo, self->_id,
 436                 SOLVABLE_MEDIAFILE);
 437
 438         return Py_BuildValue("s", filename);
 439 }
 440
 441 PyObject *Solvable_set_license(SolvableObject *self, PyObject *args) {
 442         Solvable *solv = pool_id2solvable(self->_pool, self->_id);
 443
 444         const char *license;
 445
 446         if (!PyArg_ParseTuple(args, "s", &license)) {
 447                 /* XXX raise exception */
 448                 return NULL;
 449         }
 450
 451         repo_set_str(solv->repo, self->_id, SOLVABLE_LICENSE, license);
 452
 453         Py_RETURN_NONE;
 454 }
 455
 456 PyObject *Solvable_get_license(SolvableObject *self) {
 457         Solvable *solv = pool_id2solvable(self->_pool, self->_id);
 458
 459         const char *license = repo_lookup_str(solv->repo, self->_id,
 460                 SOLVABLE_LICENSE);
 461
 462         return Py_BuildValue("s", license);
 463 }
 464
 465 PyObject *Solvable_set_buildhost(SolvableObject *self, PyObject *args) {
 466         Solvable *solv = pool_id2solvable(self->_pool, self->_id);
 467
 468         const char *buildhost;
 469
 470         if (!PyArg_ParseTuple(args, "s", &buildhost)) {
 471                 /* XXX raise exception */
 472                 return NULL;
 473         }
 474
 475         repo_set_str(solv->repo, self->_id, SOLVABLE_BUILDHOST, buildhost);
 476
 477         Py_RETURN_NONE;
 478 }
 479
 480 PyObject *Solvable_get_buildhost(SolvableObject *self) {
 481         Solvable *solv = pool_id2solvable(self->_pool, self->_id);
 482
 483         const char *buildhost = repo_lookup_str(solv->repo, self->_id,
 484                 SOLVABLE_BUILDHOST);
 485
 486         return Py_BuildValue("s", buildhost);
 487 }
 488
 489 PyObject *Solvable_set_maintainer(SolvableObject *self, PyObject *args) {
 490         Solvable *solv = pool_id2solvable(self->_pool, self->_id);
 491
 492         const char *maintainer;
 493
 494         if (!PyArg_ParseTuple(args, "s", &maintainer)) {
 495                 /* XXX raise exception */
 496                 return NULL;
 497         }
 498
 499         repo_set_str(solv->repo, self->_id, SOLVABLE_PACKAGER, maintainer);
 500
 501         Py_RETURN_NONE;
 502 }
 503
 504 PyObject *Solvable_get_maintainer(SolvableObject *self) {
 505         Solvable *solv = pool_id2solvable(self->_pool, self->_id);
 506
 507         const char *maintainer = repo_lookup_str(solv->repo, self->_id,
 508                 SOLVABLE_PACKAGER);
 509
 510         return Py_BuildValue("s", maintainer);
 511 }
 512
 513 PyObject *Solvable_set_downloadsize(SolvableObject *self, PyObject *args) {
 514         Solvable *solv = pool_id2solvable(self->_pool, self->_id);
 515
 516         unsigned long long downloadsize;
 517
 518         if (!PyArg_ParseTuple(args, "K", &downloadsize)) {
 519                 return NULL;
 520         }
 521
 522         repo_set_num(solv->repo, self->_id, SOLVABLE_DOWNLOADSIZE, downloadsize);
 523
 524         Py_RETURN_NONE;
 525 }
 526
 527 PyObject *Solvable_get_downloadsize(SolvableObject *self) {
 528         Solvable *solv = pool_id2solvable(self->_pool, self->_id);
 529
 530         unsigned long long downloadsize = repo_lookup_num(solv->repo, self->_id,
 531                 SOLVABLE_DOWNLOADSIZE, 0);
 532
 533         return Py_BuildValue("K", downloadsize);
 534 }
 535
 536 PyObject *Solvable_set_installsize(SolvableObject *self, PyObject *args) {
 537         Solvable *solv = pool_id2solvable(self->_pool, self->_id);
 538
 539         unsigned int installedsize;
 540
 541         if (!PyArg_ParseTuple(args, "i", &installedsize)) {
 542                 /* XXX raise exception */
 543                 return NULL;
 544         }
 545
 546         repo_set_num(solv->repo, self->_id, SOLVABLE_INSTALLSIZE, installedsize);
 547
 548         Py_RETURN_NONE;
 549 }
 550
 551 PyObject *Solvable_get_installsize(SolvableObject *self) {
 552         Solvable *solv = pool_id2solvable(self->_pool, self->_id);
 553
 554         unsigned int installedsize = repo_lookup_num(solv->repo, self->_id,
 555                 SOLVABLE_INSTALLSIZE, 0);
 556
 557         return Py_BuildValue("i", installedsize);
 558 }
 559
 560 PyObject *Solvable_set_buildtime(SolvableObject *self, PyObject *args) {
 561         Solvable *solv = pool_id2solvable(self->_pool, self->_id);
 562
 563         unsigned int buildtime;
 564
 565         if (!PyArg_ParseTuple(args, "i", &buildtime)) {
 566                 /* XXX raise exception */
 567                 return NULL;
 568         }
 569
 570         repo_set_num(solv->repo, self->_id, SOLVABLE_BUILDTIME, buildtime);
 571
 572         Py_RETURN_NONE;
 573 }
 574
 575 PyObject *Solvable_get_buildtime(SolvableObject *self) {
 576         Solvable *solv = pool_id2solvable(self->_pool, self->_id);
 577
 578         unsigned int buildtime = repo_lookup_num(solv->repo, self->_id,
 579                 SOLVABLE_BUILDTIME, 0);
 580
 581         if (buildtime == 0)
 582                 Py_RETURN_NONE;
 583
 584         return Py_BuildValue("i", buildtime);
 585 }
 586