path: root/python/tag.cc

// -*- mode: cpp; mode: fold -*-
// Description								/*{{{*/
// $Id: tag.cc,v 1.3 2002/02/26 01:36:15 mdz Exp $
/* ######################################################################

   Tag - Binding for the RFC 822 tag file parser

   Upon reflection I have make the TagSection wrapper look like a map..
   The other option was to use a sequence (which nicely matches the internal
   storage) but really makes no sense to a Python Programmer.. One
   specialized lookup is provided, the FindFlag lookup - as well as the
   usual set of duplicate things to match the C++ interface.

   The TagFile interface is also slightly different, it has a built in
   internal TagSection object that is used. Do not hold onto a reference
   to a TagSection and let TagFile go out of scope! The underlying storage
   for the section will go away and it will seg.

   ##################################################################### */
									/*}}}*/
// Include Files							/*{{{*/
#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif
#include "generic.h"
#include "apt_pkgmodule.h"

#include <apt-pkg/tagfile.h>
#include <apt-pkg/fileutl.h>

#include <stdio.h>
#include <iostream>
#include <Python.h>

using namespace std;
									/*}}}*/
/* We need to keep a private copy of the data.. */
struct TagSecData : public CppPyObject<pkgTagSection>
{
   char *Data;
   bool Bytes;
#if PY_MAJOR_VERSION >= 3
   PyObject *Encoding;
#endif
};

// The owner of the TagFile is a Python file object.
struct TagFileData : public CppPyObject<pkgTagFile>
{
   TagSecData *Section;
   FileFd Fd;
   bool Bytes;
#if PY_MAJOR_VERSION >= 3
   PyObject *Encoding;
#endif
};

// Traversal and Clean for owned objects
int TagFileTraverse(PyObject *self, visitproc visit, void* arg) {
    Py_VISIT(((TagFileData *)self)->Section);
    Py_VISIT(((TagFileData *)self)->Owner);
    return 0;
}

int TagFileClear(PyObject *self) {
    Py_CLEAR(((TagFileData *)self)->Section);
    Py_CLEAR(((TagFileData *)self)->Owner);
    return 0;
}

// Helpers to return Unicode or bytes as appropriate.
#if PY_MAJOR_VERSION < 3
#define TagSecString_FromStringAndSize(self, v, len) \
    PyString_FromStringAndSize((v), (len))
#define TagSecString_FromString(self, v) CppPyString(v)
#else
static PyObject *TagSecString_FromStringAndSize(PyObject *self, const char *v,
	 				 Py_ssize_t len) {
   TagSecData *Self = (TagSecData *)self;
   if (Self->Bytes)
      return PyBytes_FromStringAndSize(v, len);
   else if (Self->Encoding)
      return PyUnicode_Decode(v, len, PyUnicode_AsString(Self->Encoding), 0);
   else
      return PyUnicode_FromStringAndSize(v, len);
}

static PyObject *TagSecString_FromString(PyObject *self, const char *v) {
   TagSecData *Self = (TagSecData *)self;
   if (Self->Bytes)
      return PyBytes_FromString(v);
   else if (Self->Encoding)
      return PyUnicode_Decode(v, strlen(v),
			      PyUnicode_AsString(Self->Encoding), 0);
   else
      return PyUnicode_FromString(v);
}
#endif


									/*}}}*/
// TagSecFree - Free a Tag Section					/*{{{*/
// ---------------------------------------------------------------------
/* */
void TagSecFree(PyObject *Obj)
{
   TagSecData *Self = (TagSecData *)Obj;
   delete [] Self->Data;
   CppDealloc<pkgTagSection>(Obj);
}
									/*}}}*/
// TagFileFree - Free a Tag File					/*{{{*/
// ---------------------------------------------------------------------
/* */
void TagFileFree(PyObject *Obj)
{
   #ifdef ALLOC_DEBUG
   std::cerr << "=== DEALLOCATING " << Obj->ob_type->tp_name << "^ ===\n";
   #endif
   PyObject_GC_UnTrack(Obj);
   TagFileData *Self = (TagFileData *)Obj;
   Py_CLEAR(Self->Section);
   Self->Object.~pkgTagFile();
   Self->Fd.~FileFd();
   Py_CLEAR(Self->Owner);
   Obj->ob_type->tp_free(Obj);
}
									/*}}}*/

// Tag Section Wrappers							/*{{{*/
static char *doc_Find =
    "find(name: str[, default = None]) -> str\n\n"
    "Find the key given by 'name' and return the value. If the key can\n"
    "not be found, return 'default'.";
static PyObject *TagSecFind(PyObject *Self,PyObject *Args)
{
   char *Name = 0;
   char *Default = 0;
   if (PyArg_ParseTuple(Args,"s|z",&Name,&Default) == 0)
      return 0;

   const char *Start;
   const char *Stop;
   if (GetCpp<pkgTagSection>(Self).Find(Name,Start,Stop) == false)
   {
      if (Default == 0)
	 Py_RETURN_NONE;
      return TagSecString_FromString(Self,Default);
   }
   return TagSecString_FromStringAndSize(Self,Start,Stop-Start);
}

static char *doc_FindRaw =
    "find_raw(name: str[, default = None] -> str\n\n"
    "Same as find(), but returns the complete 'key: value' field; instead of\n"
    "just the value.";
static PyObject *TagSecFindRaw(PyObject *Self,PyObject *Args)
{
   char *Name = 0;
   char *Default = 0;
   if (PyArg_ParseTuple(Args,"s|z",&Name,&Default) == 0)
      return 0;

   unsigned Pos;
   if (GetCpp<pkgTagSection>(Self).Find(Name,Pos) == false)
   {
      if (Default == 0)
	 Py_RETURN_NONE;
      return TagSecString_FromString(Self,Default);
   }

   const char *Start;
   const char *Stop;
   GetCpp<pkgTagSection>(Self).Get(Start,Stop,Pos);

   return TagSecString_FromStringAndSize(Self,Start,Stop-Start);
}

static char *doc_FindFlag =
    "find_flag(name: str) -> int\n\n"
    "Return 1 if the key's value is 'yes' or a similar value describing\n"
    "a boolean true. If the field does not exist, or does not have such a\n"
    "value, return 0.";
static PyObject *TagSecFindFlag(PyObject *Self,PyObject *Args)
{
   char *Name = 0;
   if (PyArg_ParseTuple(Args,"s",&Name) == 0)
      return 0;

   unsigned long Flag = 0;
   if (GetCpp<pkgTagSection>(Self).FindFlag(Name,Flag,1) == false)
   {
      Py_INCREF(Py_None);
      return Py_None;
   }
   return PyBool_FromLong(Flag);
}

static char *doc_Write =
    "write(file: int, order: List[str], rewrite: List[Tag]) -> None\n\n"
    "Rewrites the section into the given file descriptor, which should be\n"
    "a file descriptor or an object providing a fileno() method.\n"
    "\n"
    ".. versionadded:: 1.9.0";
static PyObject *TagSecWrite(PyObject *Self, PyObject *Args, PyObject *kwds)
{
   char *kwlist[] = {"file", "order", "rewrite", nullptr};
   PyObject *pFile;
   PyObject *pOrder;
   PyObject *pRewrite;
   if (PyArg_ParseTupleAndKeywords(Args,kwds, "OO!O!",kwlist, &pFile,&PyList_Type,&pOrder, &PyList_Type, &pRewrite) == 0)
      return nullptr;

   int fileno = PyObject_AsFileDescriptor(pFile);
   // handle invalid arguments
   if (fileno == -1)
   {
      PyErr_SetString(PyExc_TypeError,
                      "Argument must be string, fd or have a fileno() method");
      return 0;
   }

   FileFd file(fileno);
   const char **order = ListToCharChar(pOrder,true);
   if (order == nullptr)
      return nullptr;
   std::vector<pkgTagSection::Tag> rewrite;
   for (int I = 0; I != PySequence_Length(pRewrite); I++) {
      PyObject *item = PySequence_GetItem(pRewrite, I);
      if (!PyObject_TypeCheck(item, &PyTag_Type))
         return PyErr_SetString(PyExc_TypeError, "Wrong type for tag in list"), nullptr;
      rewrite.push_back(GetCpp<pkgTagSection::Tag>(item));
   }

   return HandleErrors(PyBool_FromLong(GetCpp<pkgTagSection>(Self).Write(file, order, rewrite)));
}


// Map access, operator []
static PyObject *TagSecMap(PyObject *Self,PyObject *Arg)
{
   const char *Name = PyObject_AsString(Arg);
   if (Name == 0)
      return 0;
   const char *Start;
   const char *Stop;
   if (GetCpp<pkgTagSection>(Self).Find(Name,Start,Stop) == false)
   {
      PyErr_SetString(PyExc_KeyError,Name);
      return 0;
   }

   return TagSecString_FromStringAndSize(Self,Start,Stop-Start);
}

// len() operation
static Py_ssize_t TagSecLength(PyObject *Self)
{
   pkgTagSection &Sec = GetCpp<pkgTagSection>(Self);
   return Sec.Count();
}

// Look like a mapping
static char *doc_Keys =
    "keys() -> list\n\n"
    "Return a list of all keys.";
static PyObject *TagSecKeys(PyObject *Self,PyObject *Args)
{
   pkgTagSection &Tags = GetCpp<pkgTagSection>(Self);
   if (PyArg_ParseTuple(Args,"") == 0)
      return 0;

   // Convert the whole configuration space into a list
   PyObject *List = PyList_New(0);
   for (unsigned int I = 0; I != Tags.Count(); I++)
   {
      const char *Start;
      const char *Stop;
      Tags.Get(Start,Stop,I);
      const char *End = Start;
      for (; End < Stop && *End != ':'; End++);

      PyObject *Obj;
      PyList_Append(List,Obj = PyString_FromStringAndSize(Start,End-Start));
      Py_DECREF(Obj);
   }
   return List;
}

#if PY_MAJOR_VERSION < 3
static char *doc_Exists =
    "has_key(name: str) -> bool\n\n"
    "Return True if the key given by 'name' exists, False otherwise.";
static PyObject *TagSecExists(PyObject *Self,PyObject *Args)
{
   char *Name = 0;
   if (PyArg_ParseTuple(Args,"s",&Name) == 0)
      return 0;

   const char *Start;
   const char *Stop;
   return PyBool_FromLong(GetCpp<pkgTagSection>(Self).Find(Name,Start,Stop));
}
#endif

static int TagSecContains(PyObject *Self,PyObject *Arg)
{
   const char *Name = PyObject_AsString(Arg);
   if (Name == 0)
      return 0;
   const char *Start;
   const char *Stop;
   if (GetCpp<pkgTagSection>(Self).Find(Name,Start,Stop) == false)
      return 0;
   return 1;
}

static char *doc_Bytes =
    "bytes() -> int\n\n"
    "Return the number of bytes this section is large.";
static PyObject *TagSecBytes(PyObject *Self,PyObject *Args)
{
   if (PyArg_ParseTuple(Args,"") == 0)
      return 0;

   return MkPyNumber(GetCpp<pkgTagSection>(Self).size());
}

static PyObject *TagSecStr(PyObject *Self)
{
   const char *Start;
   const char *Stop;
   GetCpp<pkgTagSection>(Self).GetSection(Start,Stop);
   return TagSecString_FromStringAndSize(Self,Start,Stop-Start);
}
									/*}}}*/
// TagFile Wrappers							/*{{{*/
static char *doc_Step =
    "step() -> bool\n\n"
    "Step forward in the file";
static PyObject *TagFileStep(PyObject *Self,PyObject *Args)
{
   if (PyArg_ParseTuple(Args,"") == 0)
      return 0;

   TagFileData &Obj = *(TagFileData *)Self;
   if (Obj.Object.Step(Obj.Section->Object) == false)
      return HandleErrors(PyBool_FromLong(0));

   return HandleErrors(PyBool_FromLong(1));
}

// TagFile Wrappers							/*{{{*/
static PyObject *TagFileNext(PyObject *Self)
{
   TagFileData &Obj = *(TagFileData *)Self;
   // Replace the section.
   Py_CLEAR(Obj.Section);
   Obj.Section = (TagSecData*)(&PyTagSection_Type)->tp_alloc(&PyTagSection_Type, 0);
   new (&Obj.Section->Object) pkgTagSection();
   Obj.Section->Owner = Self;
   Py_INCREF(Obj.Section->Owner);
   Obj.Section->Data = 0;
   Obj.Section->Bytes = Obj.Bytes;
#if PY_MAJOR_VERSION >= 3
   // We don't need to incref Encoding as the previous Section object already
   // held a reference to it.
   Obj.Section->Encoding = Obj.Encoding;
#endif
   if (Obj.Object.Step(Obj.Section->Object) == false)
      return HandleErrors(NULL);

   // Bug-Debian: http://bugs.debian.org/572596
   // Duplicate the data here and scan the duplicated section data; in order
   // to not use any shared storage.
   // TODO: Provide an API in apt-pkg to do this; this is really ugly.

   // Fetch old section data
   const char *Start;
   const char *Stop;
   Obj.Section->Object.GetSection(Start,Stop);
   // Duplicate the data and
   //  append a \n because GetSection() will only give us a single \n
   //  but Scan() needs \n\n to work
   Obj.Section->Data = new char[Stop-Start+2];

   memcpy(Obj.Section->Data, Start, Stop - Start);
   Obj.Section->Data[Stop-Start] = '\n';
   Obj.Section->Data[Stop-Start+1] = '\0';
   // Rescan it
   if(Obj.Section->Object.Scan(Obj.Section->Data, Stop-Start+2) == false)
      return HandleErrors(NULL);

   Py_INCREF(Obj.Section);
   return HandleErrors(Obj.Section);
}

static PyObject *TagFileIter(PyObject *Self) {
    Py_INCREF(Self);
    return Self;
}

static char *doc_Offset =
    "offset() -> int\n\n"
    "Return the current offset.";
static PyObject *TagFileOffset(PyObject *Self,PyObject *Args)
{
   if (PyArg_ParseTuple(Args,"") == 0)
      return 0;
   return MkPyNumber(((TagFileData *)Self)->Object.Offset());
   
}

static char *doc_Jump =
    "jump(offset: int) -> bool\n\n"
    "Jump to the given offset; return True on success. Note that jumping to\n"
    "an offset is not very reliable, and the 'section' attribute may point\n"
    "to an unexpected section.";
static PyObject *TagFileJump(PyObject *Self,PyObject *Args)
{
   int Offset;
   if (PyArg_ParseTuple(Args,"i",&Offset) == 0)
      return 0;

   TagFileData &Obj = *(TagFileData *)Self;
   if (Obj.Object.Jump(Obj.Section->Object,Offset) == false)
      return HandleErrors(PyBool_FromLong(0));

   return HandleErrors(PyBool_FromLong(1));
}

static char *doc_Close =
    "close()\n\n"
    "Close the file.";
static PyObject *TagFileClose(PyObject *self, PyObject *args)
{
    if (args != NULL && !PyArg_ParseTuple(args, ""))
        return NULL;

   TagFileData &Obj = *(TagFileData *) self;

   Obj.Fd.Close();

   Py_INCREF(Py_None);
   return HandleErrors(Py_None);
}

static PyObject *TagFileExit(PyObject *self, PyObject *args)
{

   PyObject *exc_type = 0;
   PyObject *exc_value = 0;
   PyObject *traceback = 0;
   if (!PyArg_UnpackTuple(args, "__exit__", 3, 3, &exc_type, &exc_value,
                          &traceback)) {
       return 0;
   }

   PyObject *res = TagFileClose(self, NULL);

   if (res == NULL) {
      // The close failed. If no exception happened within the suite, we
      // will raise an error here. Otherwise, we just display the error, so
      // Python can handle the original exception instead.
      if (exc_type == Py_None)
         return NULL;

      PyErr_WriteUnraisable(self);
   } else {
      Py_DECREF(res);
   }
   // Return False, as required by the context manager protocol.
   Py_RETURN_FALSE;
}

static PyObject *TagFileEnter(PyObject *self, PyObject *args)
{
   if (!PyArg_ParseTuple(args, ""))
      return NULL;

   Py_INCREF(self);

   return self;
}

									/*}}}*/
// ParseSection - Parse a single section from a tag file		/*{{{*/
// ---------------------------------------------------------------------
static PyObject *TagSecNew(PyTypeObject *type,PyObject *Args,PyObject *kwds) {
   char *Data;
   Py_ssize_t Len;
   char Bytes = 0;
   char *kwlist[] = {"text", "bytes", 0};

   // this allows reading "byte" types from python3 - but we don't
   // make (much) use of it yet
   if (PyArg_ParseTupleAndKeywords(Args,kwds,"s#|b",kwlist,&Data,&Len,&Bytes) == 0)
      return 0;
   if (memchr(Data, 0, Len) != nullptr) {
      PyErr_SetString(PyExc_ValueError, "Input contains NUL byte");
      return 0;
   }
   if (Data[Len] != 0) {
      PyErr_SetString(PyExc_ValueError, "Input is not terminated by NUL byte");
      return 0;
   }

   // Create the object..
   TagSecData *New = (TagSecData*)type->tp_alloc(type, 0);
   new (&New->Object) pkgTagSection();
   New->Data = new char[strlen(Data)+2];
   snprintf(New->Data,strlen(Data)+2,"%s\n",Data);
   New->Bytes = Bytes;
#if PY_MAJOR_VERSION >= 3
   New->Encoding = 0;
#endif

   if (New->Object.Scan(New->Data,strlen(New->Data)) == false)
   {
      cerr << New->Data << endl;
      Py_DECREF((PyObject *)New);
      PyErr_SetString(PyExc_ValueError,"Unable to parse section data");
      return 0;
   }

   New->Object.Trim();

   return New;
}

									/*}}}*/
// ParseTagFile - Parse a tagd file					/*{{{*/
// ---------------------------------------------------------------------
/* This constructs the parser state. */

static PyObject *TagFileNew(PyTypeObject *type,PyObject *Args,PyObject *kwds)
{
   PyObject *File = 0;
   char Bytes = 0;

   char *kwlist[] = {"file", "bytes", 0};
   if (PyArg_ParseTupleAndKeywords(Args,kwds,"O|b",kwlist,&File,&Bytes) == 0)
      return 0;

   // check if we got a filename or a file object
   int fileno = -1;
   PyApt_Filename filename;
   if (!filename.init(File)) {
      PyErr_Clear();
      fileno = PyObject_AsFileDescriptor(File);
   }

   // handle invalid arguments
   if (fileno == -1 && filename == NULL)
   {
      PyErr_SetString(PyExc_TypeError, 
                      "Argument must be string, fd or have a fileno() method");
      return 0;
   }

   PyApt_UniqueObject<TagFileData> New((TagFileData*)type->tp_alloc(type, 0));
   if (fileno != -1)
   {
#ifdef APT_HAS_GZIP
      new (&New->Fd) FileFd();
      New->Fd.OpenDescriptor(fileno, FileFd::ReadOnlyGzip, false);
#else
      new (&New->Fd) FileFd(fileno,false);
#endif
   }
   else 
   {
      // FileFd::Extension got added in this revision
#if (APT_PKG_MAJOR > 4 || (APT_PKG_MAJOR >= 4 && APT_PKG_MINOR >= 12))
      new (&New->Fd) FileFd(filename, FileFd::ReadOnly, FileFd::Extension, false);
#else
      new (&New->Fd) FileFd(filename, FileFd::ReadOnly, false);
#endif
   } 
   New->Bytes = Bytes;
   New->Owner = File;
   Py_INCREF(New->Owner);
#if PY_MAJOR_VERSION >= 3
   if (fileno != -1) {
      New->Encoding = PyObject_GetAttr(File, PyUnicode_FromString("encoding"));
      if (!New->Encoding)
         PyErr_Clear();
      if (New->Encoding && !PyUnicode_Check(New->Encoding))
         New->Encoding = 0;
   } else
      New->Encoding = 0;
   Py_XINCREF(New->Encoding);
#endif
   new (&New->Object) pkgTagFile(&New->Fd);

   // Create the section
   New->Section = (TagSecData*)(&PyTagSection_Type)->tp_alloc(&PyTagSection_Type, 0);
   new (&New->Section->Object) pkgTagSection();
   New->Section->Owner = New.get();
   Py_INCREF(New->Section->Owner);
   New->Section->Data = 0;
   New->Section->Bytes = Bytes;
#if PY_MAJOR_VERSION >= 3
   New->Section->Encoding = New->Encoding;
   Py_XINCREF(New->Section->Encoding);
#endif

   return HandleErrors(New.release());
}
									/*}}}*/

// Method table for the Tag Section object
static PyMethodDef TagSecMethods[] =
{
   // Query
   {"find",TagSecFind,METH_VARARGS,doc_Find},
   {"find_raw",TagSecFindRaw,METH_VARARGS,doc_FindRaw},
   {"find_flag",TagSecFindFlag,METH_VARARGS,doc_FindFlag},
   {"bytes",TagSecBytes,METH_VARARGS,doc_Bytes},
   {"write",(PyCFunction) TagSecWrite,METH_VARARGS|METH_KEYWORDS,doc_Write},

   // Python Special
   {"keys",TagSecKeys,METH_VARARGS,doc_Keys},
#if PY_MAJOR_VERSION < 3
   {"has_key",TagSecExists,METH_VARARGS,doc_Exists},
#endif
   {"get",TagSecFind,METH_VARARGS,doc_Find},
   {}
};


PySequenceMethods TagSecSeqMeth = {0,0,0,0,0,0,0,TagSecContains,0,0};
PyMappingMethods TagSecMapMeth = {TagSecLength,TagSecMap,0};


static char *doc_TagSec = "TagSection(text: str, [bytes: bool = False])\n\n"
   "Provide methods to access RFC822-style header sections, like those\n"
   "found in debian/control or Packages files.\n\n"
   "TagSection() behave like read-only dictionaries and also provide access\n"
   "to the functions provided by the C++ class (e.g. find).\n\n"
   "By default, text read from files is treated as strings (binary data in\n"
   "Python 2, Unicode strings in Python 3). Use bytes=True to cause all\n"
   "header values read from this TagSection to be bytes even in Python 3.\n"
   "Header names are always treated as Unicode.";
PyTypeObject PyTagSection_Type =
{
   PyVarObject_HEAD_INIT(&PyType_Type, 0)
   "apt_pkg.TagSection",                // tp_name
   sizeof(TagSecData),                  // tp_basicsize
   0,                                   // tp_itemsize
   // Methods
   TagSecFree,                          // tp_dealloc
   0,                                   // tp_print
   0,                                   // tp_getattr
   0,                                   // tp_setattr
   0,                                   // tp_compare
   0,                                   // tp_repr
   0,                                   // tp_as_number
   &TagSecSeqMeth,                      // tp_as_sequence
   &TagSecMapMeth,                      // tp_as_mapping
   0,                                   // tp_hash
   0,                                   // tp_call
   TagSecStr,                           // tp_str
   _PyAptObject_getattro,               // tp_getattro
   0,                                   // tp_setattro
   0,                                   // tp_as_buffer
   (Py_TPFLAGS_DEFAULT |                // tp_flags
    Py_TPFLAGS_BASETYPE |
    Py_TPFLAGS_HAVE_GC),
   doc_TagSec,                          // tp_doc
   CppTraverse<pkgTagSection>,     // tp_traverse
   CppClear<pkgTagSection>,         // tp_clear
   0,                                   // tp_richcompare
   0,                                   // tp_weaklistoffset
   0,                                   // tp_iter
   0,                                   // tp_iternext
   TagSecMethods,                       // tp_methods
   0,                                   // tp_members
   0,                                   // tp_getset
   0,                                   // tp_base
   0,                                   // tp_dict
   0,                                   // tp_descr_get
   0,                                   // tp_descr_set
   0,                                   // tp_dictoffset
   0,                                   // tp_init
   0,                                   // tp_alloc
   TagSecNew,                           // tp_new
};

// Method table for the Tag File object
static PyMethodDef TagFileMethods[] =
{
   // Query
   {"step",TagFileStep,METH_VARARGS,doc_Step},
   {"offset",TagFileOffset,METH_VARARGS,doc_Offset},
   {"jump",TagFileJump,METH_VARARGS,doc_Jump},
   {"close",TagFileClose,METH_VARARGS,doc_Close},
   {"__enter__",TagFileEnter,METH_VARARGS,"Context manager entry, return self."},
   {"__exit__",TagFileExit,METH_VARARGS,"Context manager exit, calls close."},

   {}
};

// Return the current section.
static PyObject *TagFileGetSection(PyObject *Self,void*) {
   PyObject *Obj = ((TagFileData *)Self)->Section;
   Py_INCREF(Obj);
   return Obj;
}

static PyGetSetDef TagFileGetSet[] = {
    {"section",TagFileGetSection,0,
     "The current section, as a TagSection object.",0},
    {}
};


static char *doc_TagFile = "TagFile(file, [bytes: bool = False])\n\n"
   "TagFile() objects provide access to debian control files, which consist\n"
   "of multiple RFC822-style sections.\n\n"
   "To provide access to those sections, TagFile objects provide an iterator\n"
   "which yields TagSection objects for each section.\n\n"
   "TagFile objects also provide another API which uses a shared TagSection\n"
   "object in the 'section' member. The functions step() and jump() can be\n"
   "used to navigate within the file; offset() returns the current\n"
   "position.\n\n"
   "It is important to not mix the use of both APIs, because this can have\n"
   "unwanted effects.\n\n"
   "The parameter 'file' refers to an object providing a fileno() method or\n"
   "a file descriptor (an integer).\n\n"
   "By default, text read from files is treated as strings (binary data in\n"
   "Python 2, Unicode strings in Python 3). Use bytes=True to cause all\n"
   "header values read from this TagFile to be bytes even in Python 3.\n"
   "Header names are always treated as Unicode.";

// Type for a Tag File
PyTypeObject PyTagFile_Type =
{
   PyVarObject_HEAD_INIT(&PyType_Type, 0)
   "apt_pkg.TagFile",                   // tp_name
   sizeof(TagFileData),                 // tp_basicsize
   0,                                   // tp_itemsize
   // Methods
   TagFileFree,                         // tp_dealloc
   0,                                   // tp_print
   0,                                   // tp_getattr
   0,                                   // tp_setattr
   0,                                   // tp_compare
   0,                                   // tp_repr
   0,                                   // tp_as_number
   0,                                   // tp_as_sequence
   0,                                   // tp_as_mapping
   0,                                   // tp_hash
   0,                                   // tp_call
   0,                                   // tp_str
   _PyAptObject_getattro,               // tp_getattro
   0,                                   // tp_setattro
   0,                                   // tp_as_buffer
   (Py_TPFLAGS_DEFAULT |                // tp_flags
    Py_TPFLAGS_BASETYPE |
    Py_TPFLAGS_HAVE_GC),
   doc_TagFile,                         // tp_doc
   TagFileTraverse,                     // tp_traverse
   TagFileClear,                        // tp_clear
   0,                                   // tp_richcompare
   0,                                   // tp_weaklistoffset
   TagFileIter,                         // tp_iter
   TagFileNext,                         // tp_iternext
   TagFileMethods,                      // tp_methods
   0,                                   // tp_members
   TagFileGetSet,                       // tp_getset
   0,                                   // tp_base
   0,                                   // tp_dict
   0,                                   // tp_descr_get
   0,                                   // tp_descr_set
   0,                                   // tp_dictoffset
   0,                                   // tp_init
   0,                                   // tp_alloc
   TagFileNew,                          // tp_new

};


// Return the current section.
static PyObject *TagGetAction(PyObject *Self,void*) {
   return MkPyNumber(GetCpp<pkgTagSection::Tag>(Self).Action);
}

static PyObject *TagGetName(PyObject *Self,void*) {
   return CppPyString(GetCpp<pkgTagSection::Tag>(Self).Name);
}

static PyObject *TagGetData(PyObject *Self,void*) {
   return CppPyString(GetCpp<pkgTagSection::Tag>(Self).Data);
}

static PyObject *PyTagRename_New(PyTypeObject *type,PyObject *Args,PyObject *kwds) {
   char *oldName;
   char *newName;
   char *kwlist[] = {"old_name", "new_name", 0};

   if (PyArg_ParseTupleAndKeywords(Args,kwds,"ss",kwlist, &oldName, &newName) == 0)
      return nullptr;
   if (oldName[0] == '\0') {
      PyErr_SetString(PyExc_ValueError, "Old tag name may not be empty.");
      return nullptr;
   }
   if (newName[0] == '\0') {
      PyErr_SetString(PyExc_ValueError, "New tag name may not be empty.");
      return nullptr;
   }

   auto tag = pkgTagSection::Tag::Rename(oldName, newName);
   return CppPyObject_NEW<pkgTagSection::Tag>(nullptr, type, tag);
}

static PyObject *PyTagRewrite_New(PyTypeObject *type,PyObject *Args,PyObject *kwds) {
   char *name;
   char *data;
   char *kwlist[] = {"name", "data", 0};

   if (PyArg_ParseTupleAndKeywords(Args,kwds,"ss",kwlist, &name, &data) == 0)
      return nullptr;
   if (name[0] == '\0') {
      PyErr_SetString(PyExc_ValueError, "Tag name may not be empty.");
      return nullptr;
   }
   if (data[0] == '\0') {
      PyErr_SetString(PyExc_ValueError, "New value may not be empty.");
      return nullptr;
   }

   auto tag = pkgTagSection::Tag::Rewrite(name, data);
   return CppPyObject_NEW<pkgTagSection::Tag>(nullptr, type, tag);
}

static PyObject *PyTagRemove_New(PyTypeObject *type,PyObject *Args,PyObject *kwds) {
   char *name;
   char *kwlist[] = {"name", nullptr};

   if (PyArg_ParseTupleAndKeywords(Args,kwds,"s",kwlist, &name) == 0)
      return nullptr;
   if (name[0] == '\0') {
      PyErr_SetString(PyExc_ValueError, "Tag name may not be empty.");
      return nullptr;
   }

   auto tag = pkgTagSection::Tag::Remove(name);
   return CppPyObject_NEW<pkgTagSection::Tag>(nullptr, type, tag);
}

static PyGetSetDef TagGetSet[] = {
    {"action",TagGetAction,0,
     "The action to perform.",0},
    {"name",TagGetName,0,
     "The name of the tag to perform the action on.",0},
    {"data",TagGetData,0,
     "The data to write instead (for REWRITE), or the new tag name (RENAME)",0},
    {}
};

static char doc_Tag[] = "Tag\n\n"
   "Identify actions to be executed on a task\n"
   "\n"
   "This is used in conjunction with :meth:`TagSection.write` to rewrite\n"
   "a tag section into a new one.\n"
   "\n"
   "This class is abstract, use one of the subclasses:\n"
   ":class:`TagRewrite`, :class:`TagRemove`, :class:`TagRename`\n"
   "\n"
   ".. versionadded:: 1.1";

static char doc_TagRewrite[] = "TagRewrite(name: str, data: str)\n\n"
   "Change the value of the tag to the string passed in *data*\n"
   "\n"
   ".. versionadded:: 1.1";
static char doc_TagRename[] = "TagRename(old_name: str, new_name: str)\n\n"
   "Rename the tag *old_name* to *new_name*\n"
   "\n"
   ".. versionadded:: 1.1";

static char doc_TagRemove[] = "TagRemove(name: str)\n\n"
   "Remove the tag *name* from the tag section\n"
   "\n"
   ".. versionadded:: 1.1";


// Type for a Tag File
PyTypeObject PyTag_Type =
{
   PyVarObject_HEAD_INIT(&PyType_Type, 0)
   "apt_pkg.Tag",                   // tp_name
   sizeof(CppPyObject<pkgTagSection::Tag>),                 // tp_basicsize
   0,                                   // tp_itemsize
   // Methods
   CppDealloc<pkgTagSection::Tag>,      // tp_dealloc
   0,                                   // tp_print
   0,                                   // tp_getattr
   0,                                   // tp_setattr
   0,                                   // tp_compare
   0,                                   // tp_repr
   0,                                   // tp_as_number
   0,                                   // tp_as_sequence
   0,                                   // tp_as_mapping
   0,                                   // tp_hash
   0,                                   // tp_call
   0,                                   // tp_str
   0,                                   // tp_getattro
   0,                                   // tp_setattro
   0,                                   // tp_as_buffer
   (Py_TPFLAGS_DEFAULT                  // tp_flags
    | Py_TPFLAGS_BASETYPE),
   doc_Tag,                             // tp_doc
   CppTraverse<pkgTagSection::Tag>,     // tp_traverse
   CppClear<pkgTagSection::Tag>,        // tp_clear
   0,                                   // tp_richcompare
   0,                                   // tp_weaklistoffset
   0,                                   // tp_iter
   0,                                   // tp_iternext
   0,                                   // tp_methods
   0,                                   // tp_members
   TagGetSet,                           // tp_getset
   0,                                   // tp_base
   0,                                   // tp_dict
   0,                                   // tp_descr_get
   0,                                   // tp_descr_set
   0,                                   // tp_dictoffset
   0,                                   // tp_init
   0,                                   // tp_alloc
   0,                                   // tp_new
};

// Type for a Tag File
PyTypeObject PyTagRewrite_Type =
{
   PyVarObject_HEAD_INIT(&PyType_Type, 0)
   "apt_pkg.TagRewrite",                // tp_name
   sizeof(CppPyObject<pkgTagSection::Tag>),                 // tp_basicsize
   0,                                   // tp_itemsize
   // Methods
   CppDealloc<pkgTagSection::Tag>,      // tp_dealloc
   0,                                   // tp_print
   0,                                   // tp_getattr
   0,                                   // tp_setattr
   0,                                   // tp_compare
   0,                                   // tp_repr
   0,                                   // tp_as_number
   0,                                   // tp_as_sequence
   0,                                   // tp_as_mapping
   0,                                   // tp_hash
   0,                                   // tp_call
   0,                                   // tp_str
   0,                                   // tp_getattro
   0,                                   // tp_setattro
   0,                                   // tp_as_buffer
   Py_TPFLAGS_DEFAULT,                  // tp_flags
   doc_TagRewrite,                      // tp_doc
   CppTraverse<pkgTagSection::Tag>,     // tp_traverse
   CppClear<pkgTagSection::Tag>,        // tp_clear
   0,                                   // tp_richcompare
   0,                                   // tp_weaklistoffset
   0,                                   // tp_iter
   0,                                   // tp_iternext
   0,                                   // tp_methods
   0,                                   // tp_members
   0,                                   // tp_getset
   &PyTag_Type,                         // tp_base
   0,                                   // tp_dict
   0,                                   // tp_descr_get
   0,                                   // tp_descr_set
   0,                                   // tp_dictoffset
   0,                                   // tp_init
   0,                                   // tp_alloc
   PyTagRewrite_New,                    // tp_new
};

// Type for a Tag File
PyTypeObject PyTagRemove_Type =
{
   PyVarObject_HEAD_INIT(&PyType_Type, 0)
   "apt_pkg.TagRemove",                 // tp_name
   sizeof(CppPyObject<pkgTagSection::Tag>),                 // tp_basicsize
   0,                                   // tp_itemsize
   // Methods
   CppDealloc<pkgTagSection::Tag>,      // tp_dealloc
   0,                                   // tp_print
   0,                                   // tp_getattr
   0,                                   // tp_setattr
   0,                                   // tp_compare
   0,                                   // tp_repr
   0,                                   // tp_as_number
   0,                                   // tp_as_sequence
   0,                                   // tp_as_mapping
   0,                                   // tp_hash
   0,                                   // tp_call
   0,                                   // tp_str
   0,                                   // tp_getattro
   0,                                   // tp_setattro
   0,                                   // tp_as_buffer
   Py_TPFLAGS_DEFAULT,                  // tp_flags
   doc_TagRemove,                       // tp_doc
   CppTraverse<pkgTagSection::Tag>,     // tp_traverse
   CppClear<pkgTagSection::Tag>,        // tp_clear
   0,                                   // tp_richcompare
   0,                                   // tp_weaklistoffset
   0,                                   // tp_iter
   0,                                   // tp_iternext
   0,                                   // tp_methods
   0,                                   // tp_members
   0,                                   // tp_getset
   &PyTag_Type,                         // tp_base
   0,                                   // tp_dict
   0,                                   // tp_descr_get
   0,                                   // tp_descr_set
   0,                                   // tp_dictoffset
   0,                                   // tp_init
   0,                                   // tp_alloc
   PyTagRemove_New,                     // tp_new
};

// Type for a Tag File
PyTypeObject PyTagRename_Type =
{
   PyVarObject_HEAD_INIT(&PyType_Type, 0)
   "apt_pkg.TagRename",                 // tp_name
   sizeof(CppPyObject<pkgTagSection::Tag>),                 // tp_basicsize
   0,                                   // tp_itemsize
   // Methods
   CppDealloc<pkgTagSection::Tag>,      // tp_dealloc
   0,                                   // tp_print
   0,                                   // tp_getattr
   0,                                   // tp_setattr
   0,                                   // tp_compare
   0,                                   // tp_repr
   0,                                   // tp_as_number
   0,                                   // tp_as_sequence
   0,                                   // tp_as_mapping
   0,                                   // tp_hash
   0,                                   // tp_call
   0,                                   // tp_str
   0,                                   // tp_getattro
   0,                                   // tp_setattro
   0,                                   // tp_as_buffer
   Py_TPFLAGS_DEFAULT,                  // tp_flags
   doc_TagRename,                       // tp_doc
   CppTraverse<pkgTagSection::Tag>,     // tp_traverse
   CppClear<pkgTagSection::Tag>,        // tp_clear
   0,                                   // tp_richcompare
   0,                                   // tp_weaklistoffset
   0,                                   // tp_iter
   0,                                   // tp_iternext
   0,                                   // tp_methods
   0,                                   // tp_members
   0,                                   // tp_getset
   &PyTag_Type,                         // tp_base
   0,                                   // tp_dict
   0,                                   // tp_descr_get
   0,                                   // tp_descr_set
   0,                                   // tp_dictoffset
   0,                                   // tp_init
   0,                                   // tp_alloc
   PyTagRename_New,                     // tp_new
};