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