]>
Commit | Line | Data |
---|---|---|
b8a51cb6 MT |
1 | /*############################################################################# |
2 | # # | |
3 | # Pakfire - The IPFire package management system # | |
233c5276 | 4 | # Copyright (C) 2011 Pakfire development team # |
b8a51cb6 MT |
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 | ||
233c5276 | 23 | #include <pakfire/file.h> |
5e9463ec | 24 | #include <pakfire/filelist.h> |
233c5276 | 25 | #include <pakfire/package.h> |
843fcc66 | 26 | #include <pakfire/repo.h> |
233c5276 MT |
27 | #include <pakfire/util.h> |
28 | ||
b8a51cb6 | 29 | #include "package.h" |
cbed1552 | 30 | #include "pakfire.h" |
233c5276 | 31 | #include "repo.h" |
e1d77c57 | 32 | #include "util.h" |
b8a51cb6 | 33 | |
31480bee | 34 | PyObject* new_package(PyTypeObject* type, struct pakfire_package* pkg) { |
6029ca33 MT |
35 | PackageObject* self = (PackageObject *)type->tp_alloc(type, 0); |
36 | if (self) { | |
37 | self->package = pakfire_package_ref(pkg); | |
38 | } | |
233c5276 | 39 | |
6029ca33 | 40 | return (PyObject *)self; |
233c5276 MT |
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) { | |
233c5276 MT |
46 | self->package = NULL; |
47 | } | |
48 | ||
49 | return (PyObject *)self; | |
50 | } | |
51 | ||
52 | static void Package_dealloc(PackageObject* self) { | |
cbed1552 | 53 | pakfire_package_unref(self->package); |
233c5276 MT |
54 | |
55 | Py_TYPE(self)->tp_free((PyObject *)self); | |
56 | } | |
57 | ||
58 | static int Package_init(PackageObject* self, PyObject* args, PyObject* kwds) { | |
cbed1552 | 59 | PakfireObject* pakfire; |
0e7800fb MT |
60 | RepoObject* repo; |
61 | const char* name = NULL; | |
62 | const char* evr = NULL; | |
63 | const char* arch = NULL; | |
233c5276 | 64 | |
0e7800fb MT |
65 | if (!PyArg_ParseTuple(args, "O!O!sss", &PakfireType, &pakfire, &RepoType, &repo, |
66 | &name, &evr, &arch)) | |
233c5276 MT |
67 | return -1; |
68 | ||
0e7800fb MT |
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 | } | |
233c5276 MT |
74 | |
75 | return 0; | |
76 | } | |
77 | ||
233c5276 | 78 | static PyObject* Package_repr(PackageObject* self) { |
4a9cbd3c | 79 | const char* nevra = pakfire_package_get_nevra(self->package); |
233c5276 | 80 | |
4a9cbd3c | 81 | return PyUnicode_FromFormat("<_pakfire.Package %s>", nevra); |
233c5276 MT |
82 | } |
83 | ||
84 | static PyObject* Package_str(PackageObject* self) { | |
4a9cbd3c | 85 | const char* nevra = pakfire_package_get_nevra(self->package); |
233c5276 | 86 | |
4a9cbd3c | 87 | return PyUnicode_FromString(nevra); |
233c5276 MT |
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 | ||
233c5276 MT |
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 | ||
b28af23a MT |
196 | static PyObject* Package_get_hexdigest(PackageObject* self, enum pakfire_package_digests type) { |
197 | const char* hexdigest = pakfire_package_get_hexdigest(self->package, type); | |
198 | if (!hexdigest) | |
233c5276 MT |
199 | Py_RETURN_NONE; |
200 | ||
b28af23a | 201 | return PyUnicode_FromString(hexdigest); |
233c5276 MT |
202 | } |
203 | ||
b28af23a MT |
204 | static PyObject* Package_get_hexdigest_sha256(PackageObject* self) { |
205 | return Package_get_hexdigest(self, PAKFIRE_PACKAGE_DIGEST_SHA256); | |
206 | } | |
207 | ||
208 | static PyObject* Package_get_hexdigest_sha512(PackageObject* self) { | |
209 | return Package_get_hexdigest(self, PAKFIRE_PACKAGE_DIGEST_SHA512); | |
210 | } | |
211 | ||
212 | static int Package_set_hexdigest(PackageObject* self, | |
213 | enum pakfire_package_digests type, PyObject* value) { | |
214 | const char* hexdigest = PyUnicode_FromValue(value); | |
215 | ||
216 | return pakfire_package_set_hexdigest(self->package, type, hexdigest); | |
217 | } | |
233c5276 | 218 | |
b28af23a MT |
219 | static int Package_set_hexdigest_sha256(PackageObject* self, PyObject* value) { |
220 | return Package_set_hexdigest(self, PAKFIRE_PACKAGE_DIGEST_SHA256, value); | |
221 | } | |
222 | ||
223 | static int Package_set_hexdigest_sha512(PackageObject* self, PyObject* value) { | |
224 | return Package_set_hexdigest(self, PAKFIRE_PACKAGE_DIGEST_SHA512, value); | |
233c5276 MT |
225 | } |
226 | ||
227 | static PyObject* Package_get_summary(PackageObject* self) { | |
228 | const char* summary = pakfire_package_get_summary(self->package); | |
229 | if (!summary) | |
230 | Py_RETURN_NONE; | |
231 | ||
232 | return PyUnicode_FromString(summary); | |
233 | } | |
234 | ||
235 | static void Package_set_summary(PackageObject* self, PyObject* value) { | |
236 | const char* summary = PyUnicode_FromValue(value); | |
237 | ||
238 | pakfire_package_set_summary(self->package, summary); | |
239 | } | |
240 | ||
241 | static PyObject* Package_get_description(PackageObject* self) { | |
242 | const char* description = pakfire_package_get_description(self->package); | |
243 | if (!description) | |
244 | Py_RETURN_NONE; | |
245 | ||
246 | return PyUnicode_FromString(description); | |
247 | } | |
248 | ||
249 | static void Package_set_description(PackageObject* self, PyObject* value) { | |
250 | const char* description = PyUnicode_FromValue(value); | |
251 | ||
252 | pakfire_package_set_description(self->package, description); | |
253 | } | |
254 | ||
255 | static PyObject* Package_get_license(PackageObject* self) { | |
256 | const char* license = pakfire_package_get_license(self->package); | |
257 | if (!license) | |
258 | Py_RETURN_NONE; | |
259 | ||
260 | return PyUnicode_FromString(license); | |
261 | } | |
262 | ||
263 | static void Package_set_license(PackageObject* self, PyObject* value) { | |
264 | const char* license = PyUnicode_FromValue(value); | |
265 | ||
266 | pakfire_package_set_summary(self->package, license); | |
267 | } | |
268 | ||
269 | static PyObject* Package_get_url(PackageObject* self) { | |
270 | const char* url = pakfire_package_get_url(self->package); | |
271 | if (!url) | |
272 | Py_RETURN_NONE; | |
273 | ||
274 | return PyUnicode_FromString(url); | |
275 | } | |
276 | ||
277 | static void Package_set_url(PackageObject* self, PyObject* value) { | |
278 | const char* url = PyUnicode_FromValue(value); | |
279 | ||
280 | pakfire_package_set_url(self->package, url); | |
281 | } | |
282 | ||
283 | static PyObject* Package_get_groups(PackageObject* self) { | |
7ccc9d74 | 284 | const char* s = pakfire_package_get_groups(self->package); |
233c5276 | 285 | |
603ca1e0 | 286 | return PyUnicode_FromString(s); |
233c5276 MT |
287 | } |
288 | ||
289 | static int Package_set_groups(PackageObject* self, PyObject* value) { | |
7ccc9d74 | 290 | const char* groups = PyUnicode_AsUTF8(value); |
233c5276 | 291 | |
7ccc9d74 MT |
292 | if (groups) |
293 | pakfire_package_set_groups(self->package, groups); | |
233c5276 MT |
294 | |
295 | return 0; | |
296 | } | |
297 | ||
298 | static PyObject* Package_get_vendor(PackageObject* self) { | |
299 | const char* vendor = pakfire_package_get_vendor(self->package); | |
300 | if (!vendor) | |
301 | Py_RETURN_NONE; | |
302 | ||
303 | return PyUnicode_FromString(vendor); | |
304 | } | |
305 | ||
306 | static void Package_set_vendor(PackageObject* self, PyObject* value) { | |
307 | const char* vendor = PyUnicode_FromValue(value); | |
308 | ||
309 | pakfire_package_set_vendor(self->package, vendor); | |
310 | } | |
311 | ||
312 | static PyObject* Package_get_maintainer(PackageObject* self) { | |
313 | const char* maintainer = pakfire_package_get_maintainer(self->package); | |
314 | if (!maintainer) | |
315 | Py_RETURN_NONE; | |
316 | ||
317 | return PyUnicode_FromString(maintainer); | |
318 | } | |
319 | ||
320 | static void Package_set_maintainer(PackageObject* self, PyObject* value) { | |
321 | const char* maintainer = PyUnicode_FromValue(value); | |
322 | ||
323 | pakfire_package_set_maintainer(self->package, maintainer); | |
324 | } | |
325 | ||
326 | static PyObject* Package_get_filename(PackageObject* self) { | |
327 | const char* filename = pakfire_package_get_filename(self->package); | |
328 | if (!filename) | |
329 | Py_RETURN_NONE; | |
330 | ||
331 | return PyUnicode_FromString(filename); | |
332 | } | |
333 | ||
334 | static void Package_set_filename(PackageObject* self, PyObject* value) { | |
335 | const char* filename = PyUnicode_FromValue(value); | |
336 | ||
337 | pakfire_package_set_filename(self->package, filename); | |
338 | } | |
339 | ||
340 | static PyObject* Package_get_installed(PackageObject* self) { | |
341 | int installed = pakfire_package_is_installed(self->package); | |
342 | ||
343 | return PyBool_FromLong(installed); | |
344 | } | |
345 | ||
346 | static PyObject* Package_get_downloadsize(PackageObject* self) { | |
27116707 | 347 | size_t size = pakfire_package_get_downloadsize(self->package); |
233c5276 MT |
348 | |
349 | return PyLong_FromUnsignedLongLong(size); | |
350 | } | |
351 | ||
352 | static void Package_set_downloadsize(PackageObject* self, PyObject* value) { | |
353 | unsigned long downloadsize = PyLong_AsUnsignedLong(value); | |
354 | ||
355 | pakfire_package_set_downloadsize(self->package, downloadsize); | |
356 | } | |
357 | ||
358 | static PyObject* Package_get_installsize(PackageObject* self) { | |
27116707 | 359 | size_t size = pakfire_package_get_installsize(self->package); |
233c5276 MT |
360 | |
361 | return PyLong_FromUnsignedLongLong(size); | |
362 | } | |
363 | ||
364 | static void Package_set_installsize(PackageObject* self, PyObject* value) { | |
365 | unsigned long installsize = PyLong_AsUnsignedLong(value); | |
366 | ||
367 | pakfire_package_set_installsize(self->package, installsize); | |
368 | } | |
369 | ||
370 | static PyObject* Package_get_size(PackageObject* self) { | |
27116707 | 371 | size_t size = pakfire_package_get_size(self->package); |
233c5276 MT |
372 | |
373 | return PyLong_FromUnsignedLongLong(size); | |
374 | } | |
375 | ||
376 | static PyObject* Package_get_buildhost(PackageObject* self) { | |
2ffc704d MT |
377 | const char* build_host = pakfire_package_get_build_host(self->package); |
378 | if (!build_host) | |
233c5276 MT |
379 | Py_RETURN_NONE; |
380 | ||
2ffc704d | 381 | return PyUnicode_FromString(build_host); |
233c5276 MT |
382 | } |
383 | ||
384 | static void Package_set_buildhost(PackageObject* self, PyObject* value) { | |
2ffc704d | 385 | const char* build_host = PyUnicode_FromValue(value); |
233c5276 | 386 | |
2ffc704d | 387 | pakfire_package_set_build_host(self->package, build_host); |
b8a51cb6 | 388 | } |
233c5276 MT |
389 | |
390 | static PyObject* Package_get_buildtime(PackageObject* self) { | |
2ffc704d | 391 | time_t build_time = pakfire_package_get_build_time(self->package); |
233c5276 | 392 | |
2ffc704d | 393 | return PyLong_FromUnsignedLongLong(build_time); |
233c5276 MT |
394 | } |
395 | ||
396 | static void Package_set_buildtime(PackageObject* self, PyObject* value) { | |
2ffc704d | 397 | time_t build_time = PyLong_AsUnsignedLongLong(value); |
233c5276 | 398 | |
2ffc704d | 399 | pakfire_package_set_build_time(self->package, build_time); |
233c5276 MT |
400 | } |
401 | ||
233c5276 | 402 | static PyObject* Package_get_repo(PackageObject* self) { |
4651122b | 403 | struct pakfire_repo* repo = pakfire_package_get_repo(self->package); |
233c5276 | 404 | if (!repo) |
8ef6c388 | 405 | Py_RETURN_NONE; |
233c5276 | 406 | |
8ef6c388 | 407 | PyObject* obj = new_repo(&RepoType, repo); |
3ff6aee6 | 408 | pakfire_repo_unref(repo); |
233c5276 | 409 | |
8ef6c388 | 410 | return obj; |
233c5276 MT |
411 | } |
412 | ||
b12a5d7d MT |
413 | static PyObject* Package_get_path(PackageObject* self) { |
414 | const char* path = pakfire_package_get_path(self->package); | |
415 | if (!path) { | |
416 | PyErr_SetFromErrno(PyExc_OSError); | |
417 | return NULL; | |
418 | } | |
233c5276 | 419 | |
b12a5d7d | 420 | return PyUnicode_FromString(path); |
233c5276 MT |
421 | } |
422 | ||
452d3833 | 423 | static PyObject* PyList_FromRelationList(char** deps) { |
233c5276 MT |
424 | PyObject* list = PyList_New(0); |
425 | if (list == NULL) | |
426 | return NULL; | |
427 | ||
452d3833 MT |
428 | // Empty list? |
429 | if (!deps) | |
430 | return list; | |
233c5276 | 431 | |
452d3833 MT |
432 | for (char** dep = deps; *dep; dep++) { |
433 | PyObject* obj = PyUnicode_FromString(*dep); | |
434 | if (!obj) | |
435 | break; | |
233c5276 | 436 | |
452d3833 MT |
437 | PyList_Append(list, obj); |
438 | Py_DECREF(obj); | |
233c5276 MT |
439 | } |
440 | ||
441 | return list; | |
233c5276 MT |
442 | } |
443 | ||
452d3833 MT |
444 | static PyObject* Package_get_provides(PackageObject* self) { |
445 | char** deps = pakfire_package_get_provides(self->package); | |
233c5276 | 446 | |
452d3833 | 447 | PyObject* list = PyList_FromRelationList(deps); |
233c5276 | 448 | |
452d3833 MT |
449 | if (deps) { |
450 | for (char** dep = deps; *dep; dep++) | |
451 | free(*dep); | |
452 | free(deps); | |
233c5276 MT |
453 | } |
454 | ||
233c5276 MT |
455 | return list; |
456 | } | |
457 | ||
233c5276 | 458 | static PyObject* Package_get_requires(PackageObject* self) { |
452d3833 | 459 | char** deps = pakfire_package_get_requires(self->package); |
233c5276 | 460 | |
452d3833 | 461 | PyObject* list = PyList_FromRelationList(deps); |
233c5276 | 462 | |
452d3833 MT |
463 | if (deps) { |
464 | for (char** dep = deps; *dep; dep++) | |
465 | free(*dep); | |
466 | free(deps); | |
467 | } | |
233c5276 MT |
468 | |
469 | return list; | |
470 | } | |
471 | ||
452d3833 MT |
472 | static PyObject* Package_get_obsoletes(PackageObject* self) { |
473 | char** deps = pakfire_package_get_obsoletes(self->package); | |
233c5276 | 474 | |
452d3833 | 475 | PyObject* list = PyList_FromRelationList(deps); |
233c5276 | 476 | |
452d3833 MT |
477 | if (deps) { |
478 | for (char** dep = deps; *dep; dep++) | |
479 | free(*dep); | |
480 | free(deps); | |
481 | } | |
233c5276 MT |
482 | |
483 | return list; | |
484 | } | |
485 | ||
452d3833 MT |
486 | static PyObject* Package_get_conflicts(PackageObject* self) { |
487 | char** deps = pakfire_package_get_conflicts(self->package); | |
233c5276 | 488 | |
452d3833 | 489 | PyObject* list = PyList_FromRelationList(deps); |
233c5276 | 490 | |
452d3833 MT |
491 | if (deps) { |
492 | for (char** dep = deps; *dep; dep++) | |
493 | free(*dep); | |
494 | free(deps); | |
495 | } | |
233c5276 MT |
496 | |
497 | return list; | |
498 | } | |
499 | ||
452d3833 MT |
500 | static PyObject* Package_get_recommends(PackageObject* self) { |
501 | char** deps = pakfire_package_get_recommends(self->package); | |
233c5276 | 502 | |
452d3833 | 503 | PyObject* list = PyList_FromRelationList(deps); |
233c5276 | 504 | |
452d3833 MT |
505 | if (deps) { |
506 | for (char** dep = deps; *dep; dep++) | |
507 | free(*dep); | |
508 | free(deps); | |
509 | } | |
233c5276 MT |
510 | |
511 | return list; | |
512 | } | |
513 | ||
452d3833 MT |
514 | static PyObject* Package_get_suggests(PackageObject* self) { |
515 | char** deps = pakfire_package_get_suggests(self->package); | |
233c5276 | 516 | |
452d3833 | 517 | PyObject* list = PyList_FromRelationList(deps); |
233c5276 | 518 | |
452d3833 MT |
519 | if (deps) { |
520 | for (char** dep = deps; *dep; dep++) | |
521 | free(*dep); | |
522 | free(deps); | |
523 | } | |
233c5276 | 524 | |
452d3833 | 525 | return list; |
233c5276 MT |
526 | } |
527 | ||
e1d77c57 MT |
528 | static PyObject* Package_get_reverse_requires(PackageObject* self) { |
529 | struct pakfire_packagelist* list = NULL; | |
530 | ||
531 | int r = pakfire_package_get_reverse_requires(self->package, &list); | |
532 | if (r) { | |
533 | PyErr_SetFromErrno(PyExc_OSError); | |
534 | return NULL; | |
535 | } | |
536 | ||
537 | PyObject* object = PyList_FromPackageList(list); | |
538 | pakfire_packagelist_unref(list); | |
539 | ||
540 | return object; | |
541 | } | |
542 | ||
233c5276 MT |
543 | static PyObject* Package_get_filelist(PackageObject* self, PyObject* args) { |
544 | PyObject* list = PyList_New(0); | |
545 | if (list == NULL) | |
546 | return NULL; | |
547 | ||
1bbbfb9e | 548 | struct pakfire_filelist* filelist = pakfire_package_get_filelist(self->package); |
5e9463ec | 549 | for (unsigned int i = 0; i < pakfire_filelist_size(filelist); i++) { |
5803b5f6 | 550 | struct pakfire_file* file = pakfire_filelist_get(filelist, i); |
32485f6c | 551 | const char* path = pakfire_file_get_path(file); |
5e9463ec | 552 | pakfire_file_unref(file); |
233c5276 | 553 | |
32485f6c | 554 | PyObject* obj = PyUnicode_FromString(path); |
233c5276 MT |
555 | |
556 | int ret = PyList_Append(list, obj); | |
557 | Py_DECREF(obj); | |
558 | ||
5e9463ec MT |
559 | if (ret) { |
560 | pakfire_filelist_unref(filelist); | |
561 | Py_DECREF(list); | |
233c5276 | 562 | |
5e9463ec MT |
563 | return NULL; |
564 | } | |
233c5276 MT |
565 | } |
566 | ||
5e9463ec | 567 | pakfire_filelist_unref(filelist); |
233c5276 | 568 | |
5e9463ec | 569 | return list; |
233c5276 MT |
570 | } |
571 | ||
572 | static int Package_set_filelist(PackageObject* self, PyObject* value) { | |
573 | if (!PySequence_Check(value)) { | |
574 | PyErr_SetString(PyExc_AttributeError, "Expected a sequence."); | |
575 | return -1; | |
576 | } | |
577 | ||
ac4c607b | 578 | struct pakfire* pakfire = pakfire_package_get_pakfire(self->package); |
883b3be9 | 579 | |
5e9463ec | 580 | // Create a new filelist |
1bbbfb9e | 581 | struct pakfire_filelist* filelist; |
5e9463ec | 582 | |
883b3be9 | 583 | int r = pakfire_filelist_create(&filelist, pakfire); |
5e9463ec | 584 | if (r) { |
883b3be9 | 585 | pakfire_unref(pakfire); |
5e9463ec MT |
586 | errno = -r; |
587 | PyErr_SetFromErrno(PyExc_OSError); | |
588 | ||
589 | return -1; | |
590 | } | |
233c5276 MT |
591 | |
592 | const int length = PySequence_Length(value); | |
593 | for (int i = 0; i < length; i++) { | |
594 | PyObject* item = PySequence_GetItem(value, i); | |
595 | ||
596 | if (!PyUnicode_Check(item)) { | |
597 | Py_DECREF(item); | |
5e9463ec | 598 | pakfire_filelist_unref(filelist); |
883b3be9 | 599 | pakfire_unref(pakfire); |
233c5276 MT |
600 | |
601 | PyErr_SetString(PyExc_AttributeError, "Expected a string"); | |
602 | return -1; | |
603 | } | |
604 | ||
32485f6c | 605 | const char* path = PyUnicode_AsUTF8(item); |
5e9463ec MT |
606 | Py_DECREF(item); |
607 | ||
608 | // Create a new file | |
5803b5f6 | 609 | struct pakfire_file* file; |
233c5276 | 610 | |
883b3be9 | 611 | r = pakfire_file_create(&file, pakfire); |
5e9463ec MT |
612 | if (r) { |
613 | errno = -r; | |
614 | PyErr_SetFromErrno(PyExc_OSError); | |
615 | pakfire_filelist_unref(filelist); | |
883b3be9 | 616 | pakfire_unref(pakfire); |
5e9463ec MT |
617 | return -1; |
618 | } | |
233c5276 | 619 | |
32485f6c MT |
620 | // Set the path |
621 | pakfire_file_set_path(file, path); | |
233c5276 | 622 | |
5e9463ec MT |
623 | // Append the file to the filelist |
624 | pakfire_filelist_append(filelist, file); | |
625 | pakfire_file_unref(file); | |
626 | } | |
627 | ||
628 | // Set filelist | |
629 | r = pakfire_package_set_filelist(self->package, filelist); | |
630 | pakfire_filelist_unref(filelist); | |
631 | ||
632 | if (r) { | |
883b3be9 MT |
633 | pakfire_unref(pakfire); |
634 | ||
5e9463ec MT |
635 | errno = -r; |
636 | PyErr_SetFromErrno(PyExc_OSError); | |
637 | ||
638 | return -1; | |
233c5276 MT |
639 | } |
640 | ||
883b3be9 MT |
641 | pakfire_unref(pakfire); |
642 | ||
233c5276 MT |
643 | return 0; |
644 | } | |
645 | ||
646 | static PyObject* Package_dump(PackageObject* self, PyObject *args, PyObject* kwds) { | |
647 | static char* kwlist[] = {"long", "filelist", NULL}; | |
648 | ||
649 | int long_format = 0; | |
650 | int filelist = 0; | |
651 | ||
652 | if (!PyArg_ParseTupleAndKeywords(args, kwds, "|ii", kwlist, &long_format, &filelist)) | |
653 | return NULL; | |
654 | ||
655 | int flags = 0; | |
656 | if (long_format) | |
657 | flags |= PAKFIRE_PKG_DUMP_LONG; | |
658 | ||
659 | if (filelist) | |
660 | flags |= PAKFIRE_PKG_DUMP_FILELIST; | |
661 | ||
662 | char* package_dump = pakfire_package_dump(self->package, flags); | |
663 | ||
664 | if (!package_dump) | |
665 | Py_RETURN_NONE; | |
666 | ||
667 | return PyUnicode_FromString(package_dump); | |
668 | } | |
669 | ||
670 | static struct PyMethodDef Package_methods[] = { | |
233c5276 MT |
671 | { |
672 | "dump", | |
673 | (PyCFunction)Package_dump, | |
674 | METH_VARARGS|METH_KEYWORDS, | |
675 | NULL | |
676 | }, | |
677 | { NULL }, | |
678 | }; | |
679 | ||
680 | static struct PyGetSetDef Package_getsetters[] = { | |
681 | { | |
682 | "name", | |
683 | (getter)Package_get_name, | |
684 | (setter)Package_set_name, | |
685 | NULL, | |
686 | NULL | |
687 | }, | |
233c5276 MT |
688 | { |
689 | "evr", | |
690 | (getter)Package_get_evr, | |
691 | NULL, | |
692 | NULL, | |
693 | NULL | |
694 | }, | |
695 | { | |
696 | "arch", | |
697 | (getter)Package_get_arch, | |
698 | (setter)Package_set_arch, | |
699 | NULL, | |
700 | NULL | |
701 | }, | |
702 | { | |
703 | "uuid", | |
704 | (getter)Package_get_uuid, | |
705 | (setter)Package_set_uuid, | |
706 | NULL, | |
707 | NULL | |
708 | }, | |
709 | { | |
b28af23a MT |
710 | "hexdigest_sha256", |
711 | (getter)Package_get_hexdigest_sha256, | |
712 | (setter)Package_set_hexdigest_sha256, | |
713 | NULL, | |
714 | NULL | |
715 | }, | |
716 | { | |
717 | "hexdigest_sha512", | |
718 | (getter)Package_get_hexdigest_sha512, | |
719 | (setter)Package_set_hexdigest_sha512, | |
233c5276 MT |
720 | NULL, |
721 | NULL | |
722 | }, | |
723 | { | |
724 | "summary", | |
725 | (getter)Package_get_summary, | |
726 | (setter)Package_set_summary, | |
727 | NULL, | |
728 | NULL | |
729 | }, | |
730 | { | |
731 | "description", | |
732 | (getter)Package_get_description, | |
733 | (setter)Package_set_description, | |
734 | NULL, | |
735 | NULL | |
736 | }, | |
737 | { | |
738 | "license", | |
739 | (getter)Package_get_license, | |
740 | (setter)Package_set_license, | |
741 | NULL, | |
742 | NULL | |
743 | }, | |
744 | { | |
745 | "url", | |
746 | (getter)Package_get_url, | |
747 | (setter)Package_set_url, | |
748 | NULL, | |
749 | NULL | |
750 | }, | |
751 | { | |
752 | "groups", | |
753 | (getter)Package_get_groups, | |
754 | (setter)Package_set_groups, | |
755 | NULL, | |
756 | NULL | |
757 | }, | |
758 | { | |
759 | "vendor", | |
760 | (getter)Package_get_vendor, | |
761 | (setter)Package_set_vendor, | |
762 | NULL, | |
763 | NULL | |
764 | }, | |
765 | { | |
766 | "maintainer", | |
767 | (getter)Package_get_maintainer, | |
768 | (setter)Package_set_maintainer, | |
769 | NULL, | |
770 | NULL | |
771 | }, | |
772 | { | |
773 | "filename", | |
774 | (getter)Package_get_filename, | |
775 | (setter)Package_set_filename, | |
776 | NULL, | |
777 | NULL | |
778 | }, | |
779 | { | |
780 | "installed", | |
781 | (getter)Package_get_installed, | |
782 | NULL, | |
783 | NULL, | |
784 | NULL | |
785 | }, | |
786 | { | |
787 | "downloadsize", | |
788 | (getter)Package_get_downloadsize, | |
789 | (setter)Package_set_downloadsize, | |
790 | NULL, | |
791 | NULL | |
792 | }, | |
793 | { | |
794 | "installsize", | |
795 | (getter)Package_get_installsize, | |
796 | (setter)Package_set_installsize, | |
797 | NULL, | |
798 | NULL | |
799 | }, | |
800 | { | |
801 | "size", | |
802 | (getter)Package_get_size, | |
803 | NULL, | |
804 | NULL, | |
805 | NULL | |
806 | }, | |
807 | { | |
808 | "buildhost", | |
809 | (getter)Package_get_buildhost, | |
810 | (setter)Package_set_buildhost, | |
811 | NULL, | |
812 | NULL | |
813 | }, | |
814 | { | |
815 | "buildtime", | |
816 | (getter)Package_get_buildtime, | |
817 | (setter)Package_set_buildtime, | |
818 | NULL, | |
819 | NULL | |
820 | }, | |
233c5276 MT |
821 | |
822 | // Dependencies | |
823 | { | |
824 | "provides", | |
825 | (getter)Package_get_provides, | |
452d3833 | 826 | NULL, |
233c5276 MT |
827 | NULL, |
828 | NULL | |
829 | }, | |
830 | { | |
831 | "requires", | |
832 | (getter)Package_get_requires, | |
452d3833 | 833 | NULL, |
233c5276 MT |
834 | NULL, |
835 | NULL | |
836 | }, | |
837 | { | |
838 | "obsoletes", | |
839 | (getter)Package_get_obsoletes, | |
452d3833 | 840 | NULL, |
233c5276 MT |
841 | NULL, |
842 | NULL | |
843 | }, | |
844 | { | |
845 | "conflicts", | |
846 | (getter)Package_get_conflicts, | |
452d3833 | 847 | NULL, |
233c5276 MT |
848 | NULL, |
849 | NULL | |
850 | }, | |
851 | { | |
852 | "recommends", | |
853 | (getter)Package_get_recommends, | |
452d3833 | 854 | NULL, |
233c5276 MT |
855 | NULL, |
856 | NULL | |
857 | }, | |
858 | { | |
859 | "suggests", | |
860 | (getter)Package_get_suggests, | |
452d3833 | 861 | NULL, |
233c5276 MT |
862 | NULL, |
863 | NULL | |
864 | }, | |
e1d77c57 MT |
865 | { |
866 | "reverse_requires", | |
867 | (getter)Package_get_reverse_requires, | |
868 | NULL, | |
869 | NULL, | |
870 | NULL | |
871 | }, | |
233c5276 MT |
872 | |
873 | // Repository | |
874 | { | |
875 | "repo", | |
876 | (getter)Package_get_repo, | |
1b551e42 | 877 | NULL, |
233c5276 MT |
878 | NULL, |
879 | NULL | |
880 | }, | |
881 | { | |
b12a5d7d MT |
882 | "path", |
883 | (getter)Package_get_path, | |
233c5276 MT |
884 | NULL, |
885 | NULL, | |
886 | NULL | |
887 | }, | |
888 | ||
889 | // Filelist | |
890 | { | |
891 | "filelist", | |
892 | (getter)Package_get_filelist, | |
893 | (setter)Package_set_filelist, | |
894 | NULL, | |
895 | NULL | |
896 | }, | |
897 | ||
898 | { NULL } | |
899 | }; | |
900 | ||
901 | PyTypeObject PackageType = { | |
902 | PyVarObject_HEAD_INIT(NULL, 0) | |
903 | tp_name: "_pakfire.Package", | |
904 | tp_basicsize: sizeof(PackageObject), | |
905 | tp_flags: Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, | |
906 | tp_new: Package_new, | |
907 | tp_dealloc: (destructor)Package_dealloc, | |
908 | tp_init: (initproc)Package_init, | |
909 | tp_doc: "Package object", | |
910 | tp_methods: Package_methods, | |
911 | tp_getset: Package_getsetters, | |
233c5276 MT |
912 | tp_repr: (reprfunc)Package_repr, |
913 | tp_str: (reprfunc)Package_str, | |
914 | tp_richcompare: (richcmpfunc)Package_richcompare, | |
915 | }; |