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