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