← Back to branch summary

~pythoneers/ubuntu/lucid/python-apt/ltsppa

« back to all changes in this revision

Viewing changes to python/apt_pkgmodule.cc

  • Committer: Bazaar Package Importer
  • Author(s): Michael Vogt, Julian Andres Klode, Michael Vogt
  • Date: 2010-03-23 20:01:22 UTC
  • mfrom: (2.3.12 sid)
  • Revision ID: james.westby@ubuntu.com-20100323200122-3t1elea9fbjqn760
Tags: 0.7.94.2ubuntu1
https://launchpad.net/bugs/531518
Updated to the 0.7.9x series (FFe LP: #531518), this
brings us python3 support and a more PEP08 conform
API

[ Julian Andres Klode ]
* python/generic.cc:
  - Fix a memory leak when using old attribute names.
* debian/control:
  - Change priority to standard, keep -doc and -dev on optional.

[ Michael Vogt ]
* apt/cache.py:
  - make cache open silent by default (use apt.progress.base.OpProgress)
* tests/data/aptsources_ports/sources.list:
  - fix ports test-data
* debian/control
  - build against XS-Python-Versions: 2.6, 3.1
* tests/test_apt_cache.py:
  - add simple test for basic cache/dependency iteration
* apt/__init__.py:
  - only show deprecation warnings if PYTHON_APT_DEPRECATION_WARNINGS
    is set in the environment. While we do want to have the new API its
    not feasible to port all apps in the lucid timeframe. Once lucid
    is released we turn the warnings on by default again

Show diffs side-by-side

added added

removed removed

Lines of Context:
python/apt_pkgmodule.cc
13
13
#include "generic.h"
14
14
 
15
15
#include <apt-pkg/configuration.h>
 
16
#include <apt-pkg/acquire-item.h>
 
17
#include <apt-pkg/packagemanager.h>
16
18
#include <apt-pkg/version.h>
17
19
#include <apt-pkg/deblistparser.h>
18
20
#include <apt-pkg/pkgcache.h>
24
26
#include <apt-pkg/pkgsystem.h>
25
27
 
26
28
#include <sys/stat.h>
 
29
#include <libintl.h>
27
30
#include <unistd.h>
28
31
#include <Python.h>
29
32
                                                                        /*}}}*/
30
33
 
 
34
/**
 
35
 * A Python->C->Python gettext() function.
 
36
 *
 
37
 * Python's gettext() ignores setlocale() which causes a strange behavior
 
38
 * because the values received from apt-pkg respect setlocale(). We circumvent
 
39
 * this problem by calling the C version of gettext(). This is also much
 
40
 * faster.
 
41
 */
 
42
static PyObject *py_gettext(PyObject *self, PyObject *Args) {
 
43
    const char *msg;
 
44
    char *domain = "python-apt";
 
45
    if (PyArg_ParseTuple(Args,"s|s:gettext",&msg, &domain) == 0)
 
46
        return 0;
 
47
 
 
48
    return PyString_FromString(dgettext(domain, msg));
 
49
}
 
50
 
31
51
// newConfiguration - Build a new configuration class                   /*{{{*/
32
52
// ---------------------------------------------------------------------
 
53
#ifdef COMPAT_0_7
33
54
static char *doc_newConfiguration = "Construct a configuration instance";
34
55
static PyObject *newConfiguration(PyObject *self,PyObject *args)
35
56
{
36
 
   return CppPyObject_NEW<Configuration>(&ConfigurationType);
 
57
   PyErr_WarnEx(PyExc_DeprecationWarning, "apt_pkg.newConfiguration() is "
 
58
                "deprecated. Use apt_pkg.Configuration() instead.", 1);
 
59
   return CppPyObject_NEW<Configuration*>(NULL, &PyConfiguration_Type, new Configuration());
37
60
}
 
61
#endif
38
62
                                                                        /*}}}*/
39
63
 
40
64
// Version Wrappers                                                     /*{{{*/
59
83
   return Py_BuildValue("i",_system->VS->DoCmpVersion(A,A+LenA,B,B+LenB));
60
84
}
61
85
 
62
 
static char *doc_CheckDep = "CheckDep(PkgVer,DepOp,DepVer) -> int";
 
86
static char *doc_CheckDep =
 
87
    "check_dep(pkg_ver: str, dep_op: str, dep_ver: str) -> bool\n\n"
 
88
    "Check that the given requirement is fulfilled; i.e. that the version\n"
 
89
    "string given by 'pkg_ver' matches the version string 'dep_ver' under\n"
 
90
    "the condition specified by the operator 'dep_op' (<,<=,=,>=,>).\n\n"
 
91
    "This functions returns True if 'pkg_ver' matches 'dep_ver' under the\n"
 
92
    "condition 'dep_op'; e.g. this returns True:\n\n"
 
93
    "    apt_pkg.check_dep('1', '<=', '2')";
63
94
static PyObject *CheckDep(PyObject *Self,PyObject *Args)
64
95
{
65
96
   char *A;
69
100
 
70
101
   if (PyArg_ParseTuple(Args,"sss",&A,&OpStr,&B) == 0)
71
102
      return 0;
72
 
   if (*debListParser::ConvertRelation(OpStr,Op) != 0)
73
 
   {
74
 
      PyErr_SetString(PyExc_ValueError,"Bad comparision operation");
75
 
      return 0;
76
 
   }
77
 
 
78
 
   if (_system == 0)
79
 
   {
80
 
      PyErr_SetString(PyExc_ValueError,"_system not initialized");
81
 
      return 0;
82
 
   }
83
 
 
84
 
   return Py_BuildValue("i",_system->VS->CheckDep(A,Op,B));
85
 
//   return Py_BuildValue("i",pkgCheckDep(B,A,Op));
86
 
}
 
103
 
 
104
   if (strcmp(OpStr, ">") == 0) OpStr = ">>";
 
105
   if (strcmp(OpStr, "<") == 0) OpStr = "<<";
 
106
   if (*debListParser::ConvertRelation(OpStr,Op) != 0)
 
107
   {
 
108
      PyErr_SetString(PyExc_ValueError,"Bad comparision operation");
 
109
      return 0;
 
110
   }
 
111
 
 
112
   if (_system == 0)
 
113
   {
 
114
      PyErr_SetString(PyExc_ValueError,"_system not initialized");
 
115
      return 0;
 
116
   }
 
117
 
 
118
   return PyBool_FromLong(_system->VS->CheckDep(A,Op,B));
 
119
}
 
120
 
 
121
#ifdef COMPAT_0_7
 
122
static char *doc_CheckDepOld = "CheckDep(PkgVer,DepOp,DepVer) -> bool";
 
123
static PyObject *CheckDepOld(PyObject *Self,PyObject *Args)
 
124
{
 
125
   char *A;
 
126
   char *B;
 
127
   char *OpStr;
 
128
   unsigned int Op = 0;
 
129
 
 
130
   if (PyArg_ParseTuple(Args,"sss",&A,&OpStr,&B) == 0)
 
131
      return 0;
 
132
   if (*debListParser::ConvertRelation(OpStr,Op) != 0)
 
133
   {
 
134
      PyErr_SetString(PyExc_ValueError,"Bad comparision operation");
 
135
      return 0;
 
136
   }
 
137
 
 
138
   if (_system == 0)
 
139
   {
 
140
      PyErr_SetString(PyExc_ValueError,"_system not initialized");
 
141
      return 0;
 
142
   }
 
143
 
 
144
   return PyBool_FromLong(_system->VS->CheckDep(A,Op,B));
 
145
}
 
146
#endif
87
147
 
88
148
static char *doc_UpstreamVersion = "UpstreamVersion(a) -> string";
89
149
static PyObject *UpstreamVersion(PyObject *Self,PyObject *Args)
100
160
"The resulting tuples are (Pkg,Ver,Operation). Each anded dependency is a\n"
101
161
"list of or'd dependencies\n"
102
162
"Source depends are evaluated against the curernt arch and only those that\n"
103
 
"Match are returned.";
 
163
"Match are returned.\n\n"
 
164
"apt_pkg.Parse{,Src}Depends() are old forms which return >>,<< instead of >,<";
104
165
static PyObject *RealParseDepends(PyObject *Self,PyObject *Args,
105
 
                                  bool ParseArchFlags)
 
166
                                  bool ParseArchFlags, string name,
 
167
                                  bool debStyle=false)
106
168
{
107
169
   string Package;
108
170
   string Version;
112
174
   const char *Stop;
113
175
   int Len;
114
176
 
115
 
   if (PyArg_ParseTuple(Args,"s#",&Start,&Len) == 0)
 
177
   if (PyArg_ParseTuple(Args,(char *)("s#:" + name).c_str(),&Start,&Len) == 0)
116
178
      return 0;
117
179
   Stop = Start + Len;
118
180
   PyObject *List = PyList_New(0);
139
201
         PyObject *Obj;
140
202
         PyList_Append(LastRow,Obj = Py_BuildValue("sss",Package.c_str(),
141
203
                                                   Version.c_str(),
142
 
                                                pkgCache::CompTypeDeb(Op)));
 
204
                                                debStyle ? pkgCache::CompTypeDeb(Op) : pkgCache::CompType(Op)));
143
205
         Py_DECREF(Obj);
144
206
      }
145
207
 
156
218
}
157
219
static PyObject *ParseDepends(PyObject *Self,PyObject *Args)
158
220
{
159
 
   return RealParseDepends(Self,Args,false);
 
221
   return RealParseDepends(Self, Args, false, "parse_depends");
160
222
}
161
223
static PyObject *ParseSrcDepends(PyObject *Self,PyObject *Args)
162
224
{
163
 
   return RealParseDepends(Self,Args,true);
164
 
}
 
225
   return RealParseDepends(Self, Args, true, "parse_src_depends");
 
226
}
 
227
#ifdef COMPAT_0_7
 
228
static PyObject *ParseDepends_old(PyObject *Self,PyObject *Args)
 
229
{
 
230
   return RealParseDepends(Self, Args, false, "ParseDepends", true);
 
231
}
 
232
static PyObject *ParseSrcDepends_old(PyObject *Self,PyObject *Args)
 
233
{
 
234
   return RealParseDepends(Self, Args, true, "ParseSrcDepends", true);
 
235
}
 
236
#endif
165
237
                                                                        /*}}}*/
166
238
// md5sum - Compute the md5sum of a file or string                      /*{{{*/
167
239
// ---------------------------------------------------------------------
173
245
      return 0;
174
246
 
175
247
   // Digest of a string.
176
 
   if (PyString_Check(Obj) != 0)
 
248
   if (PyBytes_Check(Obj) != 0)
177
249
   {
178
250
      char *s;
179
251
      Py_ssize_t len;
180
252
      MD5Summation Sum;
181
 
      PyString_AsStringAndSize(Obj, &s, &len);
 
253
      PyBytes_AsStringAndSize(Obj, &s, &len);
182
254
      Sum.Add((const unsigned char*)s, len);
183
255
      return CppPyString(Sum.Result().Value());
184
256
   }
185
257
 
186
258
   // Digest of a file
187
 
   if (PyFile_Check(Obj) != 0)
 
259
   int Fd = PyObject_AsFileDescriptor(Obj);
 
260
   if (Fd != -1)
188
261
   {
189
262
      MD5Summation Sum;
190
 
      int Fd = fileno(PyFile_AsFile(Obj));
191
263
      struct stat St;
192
264
      if (fstat(Fd,&St) != 0 ||
193
265
          Sum.AddFD(Fd,St.st_size) == false)
213
285
      return 0;
214
286
 
215
287
   // Digest of a string.
216
 
   if (PyString_Check(Obj) != 0)
 
288
   if (PyBytes_Check(Obj) != 0)
217
289
   {
218
290
      char *s;
219
291
      Py_ssize_t len;
220
292
      SHA1Summation Sum;
221
 
      PyString_AsStringAndSize(Obj, &s, &len);
 
293
      PyBytes_AsStringAndSize(Obj, &s, &len);
222
294
      Sum.Add((const unsigned char*)s, len);
223
295
      return CppPyString(Sum.Result().Value());
224
296
   }
225
297
 
226
298
   // Digest of a file
227
 
   if (PyFile_Check(Obj) != 0)
 
299
   int Fd = PyObject_AsFileDescriptor(Obj);
 
300
   if (Fd != -1)
228
301
   {
229
302
      SHA1Summation Sum;
230
 
      int Fd = fileno(PyFile_AsFile(Obj));
231
303
      struct stat St;
232
304
      if (fstat(Fd,&St) != 0 ||
233
305
          Sum.AddFD(Fd,St.st_size) == false)
253
325
      return 0;
254
326
 
255
327
   // Digest of a string.
256
 
   if (PyString_Check(Obj) != 0)
 
328
   if (PyBytes_Check(Obj) != 0)
257
329
   {
258
330
      char *s;
259
331
      Py_ssize_t len;
260
332
      SHA256Summation Sum;
261
 
      PyString_AsStringAndSize(Obj, &s, &len);
 
333
      PyBytes_AsStringAndSize(Obj, &s, &len);
262
334
      Sum.Add((const unsigned char*)s, len);
263
335
      return CppPyString(Sum.Result().Value());
264
336
   }
265
337
 
266
338
   // Digest of a file
267
 
   if (PyFile_Check(Obj) != 0)
 
339
   int Fd = PyObject_AsFileDescriptor(Obj);
 
340
   if (Fd != -1)
268
341
   {
269
342
      SHA256Summation Sum;
270
 
      int Fd = fileno(PyFile_AsFile(Obj));
271
343
      struct stat St;
272
344
      if (fstat(Fd,&St) != 0 ||
273
345
          Sum.AddFD(Fd,St.st_size) == false)
385
457
static PyMethodDef methods[] =
386
458
{
387
459
   // Constructors
 
460
   {"init",Init,METH_VARARGS,doc_Init},
 
461
   {"init_config",InitConfig,METH_VARARGS,doc_InitConfig},
 
462
   {"init_system",InitSystem,METH_VARARGS,doc_InitSystem},
 
463
 
 
464
   // Internationalization.
 
465
   {"gettext",py_gettext,METH_VARARGS,
 
466
    "gettext(msg: str[, domain: str = 'python-apt']) -> str\n\n"
 
467
    "Translate the given string. Much Faster than Python's version and only\n"
 
468
    "does translations after setlocale() has been called."},
 
469
 
 
470
   // Tag File
 
471
   {"rewrite_section",RewriteSection,METH_VARARGS,doc_RewriteSection},
 
472
 
 
473
   // Locking
 
474
   {"get_lock",GetLock,METH_VARARGS,doc_GetLock},
 
475
   {"pkgsystem_lock",PkgSystemLock,METH_VARARGS,doc_PkgSystemLock},
 
476
   {"pkgsystem_unlock",PkgSystemUnLock,METH_VARARGS,doc_PkgSystemUnLock},
 
477
 
 
478
   // Command line
 
479
   {"read_config_file",LoadConfig,METH_VARARGS,doc_LoadConfig},
 
480
   {"read_config_dir",LoadConfigDir,METH_VARARGS,doc_LoadConfigDir},
 
481
   {"read_config_file_isc",LoadConfigISC,METH_VARARGS,doc_LoadConfig},
 
482
   {"parse_commandline",ParseCommandLine,METH_VARARGS,doc_ParseCommandLine},
 
483
 
 
484
   // Versioning
 
485
   {"version_compare",VersionCompare,METH_VARARGS,doc_VersionCompare},
 
486
   {"check_dep",CheckDep,METH_VARARGS,doc_CheckDep},
 
487
   {"upstream_version",UpstreamVersion,METH_VARARGS,doc_UpstreamVersion},
 
488
 
 
489
   // Depends
 
490
   {"parse_depends",ParseDepends,METH_VARARGS,doc_ParseDepends},
 
491
   {"parse_src_depends",ParseSrcDepends,METH_VARARGS,doc_ParseDepends},
 
492
 
 
493
   // Stuff
 
494
   {"md5sum",md5sum,METH_VARARGS,doc_md5sum},
 
495
   {"sha1sum",sha1sum,METH_VARARGS,doc_sha1sum},
 
496
   {"sha256sum",sha256sum,METH_VARARGS,doc_sha256sum},
 
497
 
 
498
   // Strings
 
499
   {"check_domain_list",StrCheckDomainList,METH_VARARGS,"CheckDomainList(String,String) -> Bool"},
 
500
   {"quote_string",StrQuoteString,METH_VARARGS,"QuoteString(String,String) -> String"},
 
501
   {"dequote_string",StrDeQuote,METH_VARARGS,"DeQuoteString(String) -> String"},
 
502
   {"size_to_str",StrSizeToStr,METH_VARARGS,"SizeToStr(int) -> String"},
 
503
   {"time_to_str",StrTimeToStr,METH_VARARGS,"TimeToStr(int) -> String"},
 
504
   {"uri_to_filename",StrURItoFileName,METH_VARARGS,"URItoFileName(String) -> String"},
 
505
   {"base64_encode",StrBase64Encode,METH_VARARGS,"Base64Encode(String) -> String"},
 
506
   {"string_to_bool",StrStringToBool,METH_VARARGS,"StringToBool(String) -> int"},
 
507
   {"time_rfc1123",StrTimeRFC1123,METH_VARARGS,"TimeRFC1123(int) -> String"},
 
508
   {"str_to_time",StrStrToTime,METH_VARARGS,"StrToTime(String) -> Int"},
 
509
 
 
510
   // DEPRECATED
 
511
   #ifdef COMPAT_0_7
 
512
   {"CheckDep",CheckDepOld,METH_VARARGS,doc_CheckDepOld},
388
513
   {"newConfiguration",newConfiguration,METH_VARARGS,doc_newConfiguration},
389
 
   {"init",Init,METH_VARARGS,doc_Init},
390
514
   {"InitConfig",InitConfig,METH_VARARGS,doc_InitConfig},
391
515
   {"InitSystem",InitSystem,METH_VARARGS,doc_InitSystem},
392
516
 
393
 
   // Tag File
394
517
   {"ParseSection",ParseSection,METH_VARARGS,doc_ParseSection},
395
518
   {"ParseTagFile",ParseTagFile,METH_VARARGS,doc_ParseTagFile},
396
519
   {"RewriteSection",RewriteSection,METH_VARARGS,doc_RewriteSection},
397
520
 
398
 
   // Locking
399
521
   {"GetLock",GetLock,METH_VARARGS,doc_GetLock},
400
522
   {"PkgSystemLock",PkgSystemLock,METH_VARARGS,doc_PkgSystemLock},
401
523
   {"PkgSystemUnLock",PkgSystemUnLock,METH_VARARGS,doc_PkgSystemUnLock},
402
524
 
403
 
   // Command line
404
525
   {"ReadConfigFile",LoadConfig,METH_VARARGS,doc_LoadConfig},
405
526
   {"ReadConfigDir",LoadConfigDir,METH_VARARGS,doc_LoadConfigDir},
406
527
   {"ReadConfigFileISC",LoadConfigISC,METH_VARARGS,doc_LoadConfig},
407
528
   {"ParseCommandLine",ParseCommandLine,METH_VARARGS,doc_ParseCommandLine},
408
529
 
409
 
   // Versioning
410
530
   {"VersionCompare",VersionCompare,METH_VARARGS,doc_VersionCompare},
411
 
   {"CheckDep",CheckDep,METH_VARARGS,doc_CheckDep},
412
531
   {"UpstreamVersion",UpstreamVersion,METH_VARARGS,doc_UpstreamVersion},
413
532
 
414
 
   // Depends
415
 
   {"ParseDepends",ParseDepends,METH_VARARGS,doc_ParseDepends},
416
 
   {"ParseSrcDepends",ParseSrcDepends,METH_VARARGS,doc_ParseDepends},
417
 
 
418
 
   // Stuff
419
 
   {"md5sum",md5sum,METH_VARARGS,doc_md5sum},
420
 
   {"sha1sum",sha1sum,METH_VARARGS,doc_sha1sum},
421
 
   {"sha256sum",sha256sum,METH_VARARGS,doc_sha256sum},
422
 
 
423
 
   // Strings
 
533
   {"ParseDepends",ParseDepends_old,METH_VARARGS,doc_ParseDepends},
 
534
   {"ParseSrcDepends",ParseSrcDepends_old,METH_VARARGS,doc_ParseDepends},
 
535
 
424
536
   {"CheckDomainList",StrCheckDomainList,METH_VARARGS,"CheckDomainList(String,String) -> Bool"},
425
537
   {"QuoteString",StrQuoteString,METH_VARARGS,"QuoteString(String,String) -> String"},
426
538
   {"DeQuoteString",StrDeQuote,METH_VARARGS,"DeQuoteString(String) -> String"},
432
544
   {"TimeRFC1123",StrTimeRFC1123,METH_VARARGS,"TimeRFC1123(int) -> String"},
433
545
   {"StrToTime",StrStrToTime,METH_VARARGS,"StrToTime(String) -> Int"},
434
546
 
435
 
   // Cache
436
547
   {"GetCache",TmpGetCache,METH_VARARGS,"GetCache() -> PkgCache"},
437
548
   {"GetDepCache",GetDepCache,METH_VARARGS,"GetDepCache(Cache) -> DepCache"},
438
549
   {"GetPkgRecords",GetPkgRecords,METH_VARARGS,"GetPkgRecords(Cache) -> PkgRecords"},
439
550
   {"GetPkgSrcRecords",GetPkgSrcRecords,METH_VARARGS,"GetPkgSrcRecords() -> PkgSrcRecords"},
440
551
   {"GetPkgSourceList",GetPkgSourceList,METH_VARARGS,"GetPkgSourceList() -> PkgSourceList"},
441
 
 
442
 
   // misc
443
552
   {"GetPkgProblemResolver",GetPkgProblemResolver,METH_VARARGS,"GetDepProblemResolver(DepCache) -> PkgProblemResolver"},
444
553
   {"GetPkgActionGroup",GetPkgActionGroup,METH_VARARGS,"GetPkgActionGroup(DepCache) -> PkgActionGroup"},
445
 
 
446
 
   // Cdrom
447
554
   {"GetCdrom",GetCdrom,METH_VARARGS,"GetCdrom() -> Cdrom"},
448
 
 
449
 
   // Acquire
450
555
   {"GetAcquire",GetAcquire,METH_VARARGS,"GetAcquire() -> Acquire"},
451
556
   {"GetPkgAcqFile",(PyCFunction)GetPkgAcqFile,METH_KEYWORDS|METH_VARARGS, doc_GetPkgAcqFile},
452
 
 
453
 
   // PkgManager
454
557
   {"GetPackageManager",GetPkgManager,METH_VARARGS,"GetPackageManager(DepCache) -> PackageManager"},
 
558
   #endif
455
559
 
456
560
   {}
457
561
};
458
562
 
459
 
static void AddStr(PyObject *Dict,const char *Itm,const char *Str)
460
 
{
461
 
   PyObject *Obj = PyString_FromString(Str);
462
 
   PyDict_SetItemString(Dict,(char *)Itm,Obj);
463
 
   Py_DECREF(Obj);
464
 
}
465
 
 
466
 
static void AddInt(PyObject *Dict,const char *Itm,unsigned long I)
467
 
{
468
 
   PyObject *Obj = Py_BuildValue("i",I);
469
 
   PyDict_SetItemString(Dict,(char *)Itm,Obj);
470
 
   Py_DECREF(Obj);
471
 
}
472
 
 
 
563
static struct _PyAptPkgAPIStruct API = {
 
564
   &PyAcquire_Type,           // acquire_type
 
565
   &PyAcquire_FromCpp,        // acquire_fromcpp
 
566
   &PyAcquire_ToCpp,          // acquire_tocpp
 
567
   &PyAcquireFile_Type,       // acquirefile_type
 
568
   &PyAcquireFile_FromCpp,    // acquirefile_fromcpp
 
569
   &PyAcquireFile_ToCpp,      // acquirefile_tocpp
 
570
   &PyAcquireItem_Type,       // acquireitem_type
 
571
   &PyAcquireItem_FromCpp,    // acquireitem_fromcpp
 
572
   &PyAcquireItem_ToCpp,      // acquireitem_type
 
573
   &PyAcquireItemDesc_Type,   // acquireitemdesc_type
 
574
   &PyAcquireItemDesc_FromCpp,// acquireitemdesc_fromcpp
 
575
   &PyAcquireItemDesc_ToCpp,  // acquireitemdesc_tocpp
 
576
   &PyAcquireWorker_Type,     // acquireworker_type
 
577
   &PyAcquireWorker_FromCpp,  // acquireworker_fromcpp
 
578
   &PyAcquireWorker_ToCpp,    // acquireworker_tocpp
 
579
   &PyActionGroup_Type,       // actiongroup_type
 
580
   &PyActionGroup_FromCpp,    // actiongroup_fromcpp
 
581
   &PyActionGroup_ToCpp,      // actiongroup_tocpp
 
582
   &PyCache_Type,             // cache_type
 
583
   &PyCache_FromCpp,          // cache_fromcpp
 
584
   &PyCache_ToCpp,            // cache_tocpp
 
585
   &PyCacheFile_Type,         // cachefile_type
 
586
   &PyCacheFile_FromCpp,      // cachefile_fromcpp
 
587
   &PyCacheFile_ToCpp,        // cachefile_tocpp
 
588
   &PyCdrom_Type,             // cdrom_type
 
589
   &PyCdrom_FromCpp,          // cdrom_fromcpp
 
590
   &PyCdrom_ToCpp,            // cdrom_tocpp
 
591
   &PyConfiguration_Type,     // configuration_type
 
592
   &PyConfiguration_FromCpp,  // configuration_fromcpp
 
593
   &PyConfiguration_ToCpp,    // configuration_tocpp
 
594
   &PyDepCache_Type,          // depcache_type
 
595
   &PyDepCache_FromCpp,       // depcache_fromcpp
 
596
   &PyDepCache_ToCpp,         // depcache_tocpp
 
597
   &PyDependency_Type,        // dependency_type
 
598
   &PyDependency_FromCpp,     // dependency_fromcpp
 
599
   &PyDependency_ToCpp,       // dependency_tocpp
 
600
   &PyDependencyList_Type,    // dependencylist_type
 
601
   0,                         // FIXME: dependencylist_fromcpp
 
602
   0,                         // FIXME: dependencylist_tocpp
 
603
   &PyDescription_Type,       // description_type
 
604
   &PyDescription_FromCpp,    // description_fromcpp
 
605
   &PyDescription_ToCpp,      // description_tocpp
 
606
   &PyHashes_Type,            // hashes_type
 
607
   &PyHashes_FromCpp,         // hashes_fromcpp
 
608
   &PyHashes_ToCpp,           // hashes_tocpp
 
609
   &PyHashString_Type,        // hashstring_type
 
610
   &PyHashString_FromCpp,     // hashstring_fromcpp
 
611
   &PyHashString_ToCpp,       // hashstring_tocpp
 
612
   &PyIndexRecords_Type,      // indexrecords_type
 
613
   &PyIndexRecords_FromCpp,     // indexrecords_tocpp
 
614
   &PyIndexRecords_ToCpp,     // indexrecords_tocpp
 
615
   &PyMetaIndex_Type,         // metaindex_type
 
616
   &PyMetaIndex_FromCpp,        // metaindex_tocpp
 
617
   &PyMetaIndex_ToCpp,        // metaindex_tocpp
 
618
   &PyPackage_Type,           // package_type
 
619
   &PyPackage_FromCpp,          // package_tocpp
 
620
   &PyPackage_ToCpp,          // package_tocpp
 
621
   &PyPackageFile_Type,       // packagefile_type
 
622
   &PyPackageFile_FromCpp,      // packagefile_tocpp
 
623
   &PyPackageFile_ToCpp,      // packagefile_tocpp
 
624
   &PyIndexFile_Type,         // packageindexfile_type
 
625
   &PyIndexFile_FromCpp,        // packageindexfile_tocpp
 
626
   &PyIndexFile_ToCpp,        // packageindexfile_tocpp
 
627
   &PyPackageList_Type,       // packagelist_type
 
628
   0,                         // FIXME: packagelist_fromcpp
 
629
   0,                         // FIXME: packagelist_tocpp
 
630
   &PyPackageManager_Type,    // packagemanager_type
 
631
   &PyPackageManager_FromCpp,   // packagemanager_type
 
632
   &PyPackageManager_ToCpp,   // packagemanager_type
 
633
   &PyPackageRecords_Type,    // packagerecords_type
 
634
   0,                         // FIXME: packagerecords_fromcpp
 
635
   0,                         // FIXME: packagerecords_tocpp
 
636
   &PyPolicy_Type,            // policy_type
 
637
   &PyPolicy_FromCpp,           // policy_tocpp
 
638
   &PyPolicy_ToCpp,           // policy_tocpp
 
639
   &PyProblemResolver_Type,   // problemresolver_type
 
640
   &PyProblemResolver_FromCpp,  // problemresolver_tocpp
 
641
   &PyProblemResolver_ToCpp,  // problemresolver_tocpp
 
642
   &PySourceList_Type,        // sourcelist_type
 
643
   &PySourceList_FromCpp,       // sourcelist_tocpp
 
644
   &PySourceList_ToCpp,       // sourcelist_tocpp
 
645
   &PySourceRecords_Type,     // sourcerecords_type
 
646
   0,                         // FIXME: sourcerecords_fromcpp
 
647
   0,                         // FIXME: sourcerecords_tocpp
 
648
   &PyTagFile_Type,           // tagfile_type
 
649
   &PyTagFile_FromCpp,          // tagfile_tocpp
 
650
   &PyTagFile_ToCpp,          // tagfile_tocpp
 
651
   &PyTagSection_Type,        // tagsection_type
 
652
   &PyTagSection_FromCpp,       // tagsection_tocpp
 
653
   &PyTagSection_ToCpp,       // tagsection_tocpp
 
654
   &PyVersion_Type,           // version_type
 
655
   &PyVersion_FromCpp,          // version_tocpp
 
656
   &PyVersion_ToCpp,          // version_tocpp
 
657
};
 
658
 
 
659
 
 
660
#define ADDTYPE(mod,name,type) { \
 
661
    if (PyType_Ready(type) == -1) INIT_ERROR; \
 
662
    Py_INCREF(type); \
 
663
    PyModule_AddObject(mod,name,(PyObject *)type); }
 
664
 
 
665
 
 
666
#if PY_MAJOR_VERSION >= 3
 
667
static struct PyModuleDef moduledef = {
 
668
        PyModuleDef_HEAD_INIT,
 
669
        "apt_pkg",
 
670
        "Classes and functions wrapping the apt-pkg library.\n\n"
 
671
        "The apt_pkg module provides...",
 
672
        -1,
 
673
        methods,
 
674
        0,
 
675
        0,
 
676
        0,
 
677
        0,
 
678
};
 
679
 
 
680
#define INIT_ERROR return 0
 
681
extern "C" PyObject * PyInit_apt_pkg()
 
682
#else
 
683
#define INIT_ERROR return
473
684
extern "C" void initapt_pkg()
 
685
#endif
474
686
{
 
687
   // Finalize our types to add slots, etc.
 
688
   if (PyType_Ready(&PyConfiguration_Type) == -1) INIT_ERROR;
 
689
   if (PyType_Ready(&PyCacheFile_Type) == -1) INIT_ERROR;
 
690
 
 
691
   // Initialize the module
 
692
   #if PY_MAJOR_VERSION >= 3
 
693
   PyObject *Module = PyModule_Create(&moduledef);
 
694
   #else
475
695
   PyObject *Module = Py_InitModule("apt_pkg",methods);
476
 
   PyObject *Dict = PyModule_GetDict(Module);
 
696
   #endif
477
697
 
478
698
   // Global variable linked to the global configuration class
479
 
   CppPyObject<Configuration *> *Config = CppPyObject_NEW<Configuration *>(&ConfigurationPtrType);
 
699
   CppPyObject<Configuration*> *Config = CppPyObject_NEW<Configuration*>(NULL, &PyConfiguration_Type);
480
700
   Config->Object = _config;
481
 
   PyDict_SetItemString(Dict,"Config",Config);
482
 
   Py_DECREF(Config);
483
 
 
 
701
   // Global configuration, should never be deleted.
 
702
   Config->NoDelete = true;
 
703
   PyModule_AddObject(Module,"config",Config);
 
704
   #ifdef COMPAT_0_7
 
705
   Py_INCREF(Config);
 
706
   PyModule_AddObject(Module,"Config",Config);
 
707
   #endif
 
708
 
 
709
 
 
710
 
 
711
 
 
712
   // Add our classes.
 
713
   /* ============================ tag.cc ============================ */
 
714
   ADDTYPE(Module,"TagSection",&PyTagSection_Type);
 
715
   ADDTYPE(Module,"TagFile",&PyTagFile_Type);
 
716
   /* ============================ acquire.cc ============================ */
 
717
   ADDTYPE(Module,"Acquire",&PyAcquire_Type);
 
718
   ADDTYPE(Module,"AcquireFile",&PyAcquireFile_Type);
 
719
   ADDTYPE(Module,"AcquireItem",&PyAcquireItem_Type); // NO __new__()
 
720
   ADDTYPE(Module,"AcquireWorker",&PyAcquireWorker_Type); // NO __new__()
 
721
   /* ============================ cache.cc ============================ */
 
722
   ADDTYPE(Module,"Cache",&PyCache_Type);
 
723
   ADDTYPE(Module,"Dependency",&PyDependency_Type); // NO __new__()
 
724
   ADDTYPE(Module,"Description",&PyDescription_Type); // NO __new__()
 
725
   ADDTYPE(Module,"PackageFile",&PyPackageFile_Type); // NO __new__()
 
726
   ADDTYPE(Module,"PackageList",&PyPackageList_Type);  // NO __new__(), internal
 
727
   ADDTYPE(Module,"DependencyList",&PyDependencyList_Type); // NO __new__(), internal
 
728
   ADDTYPE(Module,"Package",&PyPackage_Type); // NO __new__()
 
729
   ADDTYPE(Module,"Version",&PyVersion_Type); // NO __new__()
 
730
   /* ============================ cdrom.cc ============================ */
 
731
   ADDTYPE(Module,"Cdrom",&PyCdrom_Type);
 
732
   /* ========================= configuration.cc ========================= */
 
733
   ADDTYPE(Module,"Configuration",&PyConfiguration_Type);
 
734
   /* ========================= depcache.cc ========================= */
 
735
   ADDTYPE(Module,"ActionGroup",&PyActionGroup_Type);
 
736
   ADDTYPE(Module,"DepCache",&PyDepCache_Type);
 
737
   ADDTYPE(Module,"ProblemResolver",&PyProblemResolver_Type);
 
738
   /* ========================= indexfile.cc ========================= */
 
739
   ADDTYPE(Module,"IndexFile",&PyIndexFile_Type); // NO __new__()
 
740
   /* ========================= metaindex.cc ========================= */
 
741
   ADDTYPE(Module,"MetaIndex",&PyMetaIndex_Type); // NO __new__()
 
742
   /* ========================= pkgmanager.cc ========================= */
 
743
   ADDTYPE(Module,"PackageManager",&PyPackageManager_Type);
 
744
   /* ========================= pkgrecords.cc ========================= */
 
745
   ADDTYPE(Module,"PackageRecords",&PyPackageRecords_Type);
 
746
   /* ========================= pkgsrcrecords.cc ========================= */
 
747
   ADDTYPE(Module,"SourceRecords",&PySourceRecords_Type);
 
748
   /* ========================= sourcelist.cc ========================= */
 
749
   ADDTYPE(Module,"SourceList",&PySourceList_Type);
 
750
   ADDTYPE(Module,"IndexRecords",&PyIndexRecords_Type);
 
751
   ADDTYPE(Module,"HashString",&PyHashString_Type);
 
752
   ADDTYPE(Module,"Policy",&PyPolicy_Type);
 
753
   ADDTYPE(Module,"Hashes",&PyHashes_Type);
 
754
   ADDTYPE(Module,"AcquireItemDesc",&PyAcquireItemDesc_Type);
 
755
   ADDTYPE(Module,"SystemLock",&PySystemLock_Type);
 
756
   ADDTYPE(Module,"FileLock",&PyFileLock_Type);
484
757
   // Tag file constants
485
 
   PyObject *Obj;
486
 
   PyDict_SetItemString(Dict,"RewritePackageOrder",
487
 
                        Obj = CharCharToList(TFRewritePackageOrder));
488
 
   Py_DECREF(Obj);
489
 
   PyDict_SetItemString(Dict,"RewriteSourceOrder",
490
 
                        Obj = CharCharToList(TFRewriteSourceOrder));
491
 
   Py_DECREF(Obj);
492
 
 
 
758
   PyModule_AddObject(Module,"REWRITE_PACKAGE_ORDER",
 
759
                      CharCharToList(TFRewritePackageOrder));
 
760
 
 
761
   PyModule_AddObject(Module,"REWRITE_SOURCE_ORDER",
 
762
                      CharCharToList(TFRewriteSourceOrder));
 
763
 
 
764
 
 
765
   // Acquire constants.
 
766
   // some constants
 
767
   PyDict_SetItemString(PyAcquire_Type.tp_dict, "RESULT_CANCELLED",
 
768
                        Py_BuildValue("i", pkgAcquire::Cancelled));
 
769
   PyDict_SetItemString(PyAcquire_Type.tp_dict, "RESULT_CONTINUE",
 
770
                        Py_BuildValue("i", pkgAcquire::Continue));
 
771
   PyDict_SetItemString(PyAcquire_Type.tp_dict, "RESULT_FAILED",
 
772
                        Py_BuildValue("i", pkgAcquire::Failed));
 
773
#ifdef COMPAT_0_7
 
774
   PyDict_SetItemString(PyAcquire_Type.tp_dict, "ResultCancelled",
 
775
                        Py_BuildValue("i", pkgAcquire::Cancelled));
 
776
   PyDict_SetItemString(PyAcquire_Type.tp_dict, "ResultContinue",
 
777
                        Py_BuildValue("i", pkgAcquire::Continue));
 
778
   PyDict_SetItemString(PyAcquire_Type.tp_dict, "ResultFailed",
 
779
                        Py_BuildValue("i", pkgAcquire::Failed));
 
780
#endif
 
781
    // Dependency constants
 
782
   PyDict_SetItemString(PyDependency_Type.tp_dict, "TYPE_DEPENDS",
 
783
                        Py_BuildValue("i", pkgCache::Dep::Depends));
 
784
   PyDict_SetItemString(PyDependency_Type.tp_dict, "TYPE_PREDEPENDS",
 
785
                        Py_BuildValue("i", pkgCache::Dep::PreDepends));
 
786
   PyDict_SetItemString(PyDependency_Type.tp_dict, "TYPE_SUGGESTS",
 
787
                        Py_BuildValue("i", pkgCache::Dep::Suggests));
 
788
   PyDict_SetItemString(PyDependency_Type.tp_dict, "TYPE_RECOMMENDS",
 
789
                        Py_BuildValue("i", pkgCache::Dep::Suggests));
 
790
   PyDict_SetItemString(PyDependency_Type.tp_dict, "TYPE_CONFLICTS",
 
791
                        Py_BuildValue("i", pkgCache::Dep::Conflicts));
 
792
   PyDict_SetItemString(PyDependency_Type.tp_dict, "TYPE_REPLACES",
 
793
                        Py_BuildValue("i", pkgCache::Dep::Replaces));
 
794
   PyDict_SetItemString(PyDependency_Type.tp_dict, "TYPE_OBSOLETES",
 
795
                        Py_BuildValue("i", pkgCache::Dep::Obsoletes));
 
796
   PyDict_SetItemString(PyDependency_Type.tp_dict, "TYPE_DPKG_BREAKS",
 
797
                        Py_BuildValue("i", pkgCache::Dep::DpkgBreaks));
 
798
   PyDict_SetItemString(PyDependency_Type.tp_dict, "TYPE_ENHANCES",
 
799
                        Py_BuildValue("i", pkgCache::Dep::Enhances));
 
800
 
 
801
 
 
802
   // PackageManager constants
 
803
   PyDict_SetItemString(PyPackageManager_Type.tp_dict, "RESULT_COMPLETED",
 
804
                        Py_BuildValue("i", pkgPackageManager::Completed));
 
805
   PyDict_SetItemString(PyPackageManager_Type.tp_dict, "RESULT_FAILED",
 
806
                        Py_BuildValue("i", pkgPackageManager::Failed));
 
807
   PyDict_SetItemString(PyPackageManager_Type.tp_dict, "RESULT_INCOMPLETE",
 
808
                        Py_BuildValue("i", pkgPackageManager::Incomplete));
 
809
 
 
810
#ifdef COMPAT_0_7
 
811
   PyDict_SetItemString(PyPackageManager_Type.tp_dict, "ResultCompleted",
 
812
                        Py_BuildValue("i", pkgPackageManager::Completed));
 
813
   PyDict_SetItemString(PyPackageManager_Type.tp_dict, "ResultFailed",
 
814
                        Py_BuildValue("i", pkgPackageManager::Failed));
 
815
   PyDict_SetItemString(PyPackageManager_Type.tp_dict, "ResultIncomplete",
 
816
                        Py_BuildValue("i", pkgPackageManager::Incomplete));
 
817
#endif
 
818
 
 
819
   // AcquireItem Constants.
 
820
   PyDict_SetItemString(PyAcquireItem_Type.tp_dict, "STAT_IDLE",
 
821
                        Py_BuildValue("i", pkgAcquire::Item::StatIdle));
 
822
   PyDict_SetItemString(PyAcquireItem_Type.tp_dict, "STAT_FETCHING",
 
823
                        Py_BuildValue("i", pkgAcquire::Item::StatFetching));
 
824
   PyDict_SetItemString(PyAcquireItem_Type.tp_dict, "STAT_DONE",
 
825
                        Py_BuildValue("i", pkgAcquire::Item::StatDone));
 
826
   PyDict_SetItemString(PyAcquireItem_Type.tp_dict, "STAT_ERROR",
 
827
                        Py_BuildValue("i", pkgAcquire::Item::StatError));
 
828
   PyDict_SetItemString(PyAcquireItem_Type.tp_dict, "STAT_AUTH_ERROR",
 
829
                        Py_BuildValue("i", pkgAcquire::Item::StatAuthError));
 
830
 
 
831
#ifdef COMPAT_0_7
 
832
   PyDict_SetItemString(PyAcquireItem_Type.tp_dict, "StatIdle",
 
833
                        Py_BuildValue("i", pkgAcquire::Item::StatIdle));
 
834
   PyDict_SetItemString(PyAcquireItem_Type.tp_dict, "StatFetching",
 
835
                        Py_BuildValue("i", pkgAcquire::Item::StatFetching));
 
836
   PyDict_SetItemString(PyAcquireItem_Type.tp_dict, "StatDone",
 
837
                        Py_BuildValue("i", pkgAcquire::Item::StatDone));
 
838
   PyDict_SetItemString(PyAcquireItem_Type.tp_dict, "StatError",
 
839
                        Py_BuildValue("i", pkgAcquire::Item::StatError));
 
840
   PyDict_SetItemString(PyAcquireItem_Type.tp_dict, "StatAuthError",
 
841
                        Py_BuildValue("i", pkgAcquire::Item::StatAuthError));
 
842
#endif
 
843
 
 
844
#if PY_MAJOR_VERSION >= 3 && PY_MINOR_VERSION >= 1
 
845
   PyObject *PyCapsule = PyCapsule_New(&API, "apt_pkg._C_API", NULL);
 
846
#else
 
847
   PyObject *PyCapsule = PyCObject_FromVoidPtr(&API, NULL);
 
848
#endif
 
849
   PyModule_AddObject(Module, "_C_API", PyCapsule);
493
850
   // Version..
494
 
   AddStr(Dict,"Version",pkgVersion);
495
 
   AddStr(Dict,"LibVersion",pkgLibVersion);
496
 
   AddStr(Dict,"Date",__DATE__);
497
 
   AddStr(Dict,"Time",__TIME__);
 
851
   PyModule_AddStringConstant(Module,"VERSION",(char *)pkgVersion);
 
852
   PyModule_AddStringConstant(Module,"LIB_VERSION",(char *)pkgLibVersion);
 
853
   PyModule_AddStringConstant(Module,"DATE",__DATE__);
 
854
   PyModule_AddStringConstant(Module,"TIME",__TIME__);
498
855
 
499
856
   // My constants
500
 
   AddInt(Dict,"DepDepends",pkgCache::Dep::Depends);
501
 
   AddInt(Dict,"DepPreDepends",pkgCache::Dep::PreDepends);
502
 
   AddInt(Dict,"DepSuggests",pkgCache::Dep::Suggests);
503
 
   AddInt(Dict,"DepRecommends",pkgCache::Dep::Recommends);
504
 
   AddInt(Dict,"DepConflicts",pkgCache::Dep::Conflicts);
505
 
   AddInt(Dict,"DepReplaces",pkgCache::Dep::Replaces);
506
 
   AddInt(Dict,"DepObsoletes",pkgCache::Dep::Obsoletes);
507
 
   AddInt(Dict,"DepDpkgBreaks",pkgCache::Dep::DpkgBreaks);
508
 
   AddInt(Dict,"DepEnhances",pkgCache::Dep::Enhances);
509
 
 
510
 
   AddInt(Dict,"PriImportant",pkgCache::State::Important);
511
 
   AddInt(Dict,"PriRequired",pkgCache::State::Required);
512
 
   AddInt(Dict,"PriStandard",pkgCache::State::Standard);
513
 
   AddInt(Dict,"PriOptional",pkgCache::State::Optional);
514
 
   AddInt(Dict,"PriExtra",pkgCache::State::Extra);
515
 
 
516
 
   AddInt(Dict,"CurStateNotInstalled",pkgCache::State::NotInstalled);
517
 
   AddInt(Dict,"CurStateUnPacked",pkgCache::State::UnPacked);
518
 
   AddInt(Dict,"CurStateHalfConfigured",pkgCache::State::HalfConfigured);
519
 
   AddInt(Dict,"CurStateHalfInstalled",pkgCache::State::HalfInstalled);
520
 
   AddInt(Dict,"CurStateConfigFiles",pkgCache::State::ConfigFiles);
521
 
   AddInt(Dict,"CurStateInstalled",pkgCache::State::Installed);
522
 
 
523
 
   AddInt(Dict,"SelStateUnknown",pkgCache::State::Unknown);
524
 
   AddInt(Dict,"SelStateInstall",pkgCache::State::Install);
525
 
   AddInt(Dict,"SelStateHold",pkgCache::State::Hold);
526
 
   AddInt(Dict,"SelStateDeInstall",pkgCache::State::DeInstall);
527
 
   AddInt(Dict,"SelStatePurge",pkgCache::State::Purge);
528
 
 
529
 
   AddInt(Dict,"InstStateOk",pkgCache::State::Ok);
530
 
   AddInt(Dict,"InstStateReInstReq",pkgCache::State::ReInstReq);
531
 
   AddInt(Dict,"InstStateHold",pkgCache::State::Hold);
532
 
   AddInt(Dict,"InstStateHoldReInstReq",pkgCache::State::HoldReInstReq);
 
857
   PyModule_AddIntConstant(Module,"PRI_IMPORTANT",pkgCache::State::Important);
 
858
   PyModule_AddIntConstant(Module,"PRI_REQUIRED",pkgCache::State::Required);
 
859
   PyModule_AddIntConstant(Module,"PRI_STANDARD",pkgCache::State::Standard);
 
860
   PyModule_AddIntConstant(Module,"PRI_OPTIONAL",pkgCache::State::Optional);
 
861
   PyModule_AddIntConstant(Module,"PRI_EXTRA",pkgCache::State::Extra);
 
862
   // CurState
 
863
   PyModule_AddIntConstant(Module,"CURSTATE_NOT_INSTALLED",pkgCache::State::NotInstalled);
 
864
   PyModule_AddIntConstant(Module,"CURSTATE_UNPACKED",pkgCache::State::UnPacked);
 
865
   PyModule_AddIntConstant(Module,"CURSTATE_HALF_CONFIGURED",pkgCache::State::HalfConfigured);
 
866
   PyModule_AddIntConstant(Module,"CURSTATE_HALF_INSTALLED",pkgCache::State::HalfInstalled);
 
867
   PyModule_AddIntConstant(Module,"CURSTATE_CONFIG_FILES",pkgCache::State::ConfigFiles);
 
868
   PyModule_AddIntConstant(Module,"CURSTATE_INSTALLED",pkgCache::State::Installed);
 
869
   // SelState
 
870
   PyModule_AddIntConstant(Module,"SELSTATE_UNKNOWN",pkgCache::State::Unknown);
 
871
   PyModule_AddIntConstant(Module,"SELSTATE_INSTALL",pkgCache::State::Install);
 
872
   PyModule_AddIntConstant(Module,"SELSTATE_HOLD",pkgCache::State::Hold);
 
873
   PyModule_AddIntConstant(Module,"SELSTATE_DEINSTALL",pkgCache::State::DeInstall);
 
874
   PyModule_AddIntConstant(Module,"SELSTATE_PURGE",pkgCache::State::Purge);
 
875
   // InstState
 
876
   PyModule_AddIntConstant(Module,"INSTSTATE_OK",pkgCache::State::Ok);
 
877
   PyModule_AddIntConstant(Module,"INSTSTATE_REINSTREQ",pkgCache::State::ReInstReq);
 
878
   PyModule_AddIntConstant(Module,"INSTSTATE_HOLD",pkgCache::State::Hold);
 
879
   PyModule_AddIntConstant(Module,"INSTSTATE_HOLD_REINSTREQ",pkgCache::State::HoldReInstReq);
 
880
 
 
881
   // DEPRECATED API
 
882
   #ifdef COMPAT_0_7
 
883
   PyModule_AddObject(Module,"RewritePackageOrder",
 
884
                      CharCharToList(TFRewritePackageOrder));
 
885
   PyModule_AddObject(Module,"RewriteSourceOrder",
 
886
                      CharCharToList(TFRewriteSourceOrder));
 
887
   PyModule_AddStringConstant(Module,"LibVersion",(char *)pkgLibVersion);
 
888
   PyModule_AddStringConstant(Module,"Date",__DATE__);
 
889
   PyModule_AddStringConstant(Module,"Time",__TIME__);
 
890
   PyModule_AddIntConstant(Module,"PriImportant",pkgCache::State::Important);
 
891
   PyModule_AddIntConstant(Module,"PriRequired",pkgCache::State::Required);
 
892
   PyModule_AddIntConstant(Module,"PriStandard",pkgCache::State::Standard);
 
893
   PyModule_AddIntConstant(Module,"PriOptional",pkgCache::State::Optional);
 
894
   PyModule_AddIntConstant(Module,"PriExtra",pkgCache::State::Extra);
 
895
   PyModule_AddIntConstant(Module,"CurStateNotInstalled",pkgCache::State::NotInstalled);
 
896
   PyModule_AddIntConstant(Module,"CurStateUnPacked",pkgCache::State::UnPacked);
 
897
   PyModule_AddIntConstant(Module,"CurStateHalfConfigured",pkgCache::State::HalfConfigured);
 
898
   PyModule_AddIntConstant(Module,"CurStateHalfInstalled",pkgCache::State::HalfInstalled);
 
899
   PyModule_AddIntConstant(Module,"CurStateConfigFiles",pkgCache::State::ConfigFiles);
 
900
   PyModule_AddIntConstant(Module,"CurStateInstalled",pkgCache::State::Installed);
 
901
   PyModule_AddIntConstant(Module,"SelStateUnknown",pkgCache::State::Unknown);
 
902
   PyModule_AddIntConstant(Module,"SelStateInstall",pkgCache::State::Install);
 
903
   PyModule_AddIntConstant(Module,"SelStateHold",pkgCache::State::Hold);
 
904
   PyModule_AddIntConstant(Module,"SelStateDeInstall",pkgCache::State::DeInstall);
 
905
   PyModule_AddIntConstant(Module,"SelStatePurge",pkgCache::State::Purge);
 
906
   PyModule_AddIntConstant(Module,"InstStateOk",pkgCache::State::Ok);
 
907
   PyModule_AddIntConstant(Module,"InstStateReInstReq",pkgCache::State::ReInstReq);
 
908
   PyModule_AddIntConstant(Module,"InstStateHold",pkgCache::State::Hold);
 
909
   PyModule_AddIntConstant(Module,"InstStateHoldReInstReq",pkgCache::State::HoldReInstReq);
 
910
   PyModule_AddIntConstant(Module,"_COMPAT_0_7",1);
 
911
   #else
 
912
   PyModule_AddIntConstant(Module,"_COMPAT_0_7",0);
 
913
   #endif
 
914
   #if PY_MAJOR_VERSION >= 3
 
915
   return Module;
 
916
   #endif
533
917
}
534
918
                                                                        /*}}}*/
535
919