Generalize access to ob_type so that they work with both Python 2.* and Python 3.*

Python 2's various object structs use macros to implement common fields at the top of each
struct.

Python 3's objects instead embed a PyObject struct as the first member within the more refined
object structs.

Use the Py_TYPE() macro when accessing ob_type in order to encapsulate this difference.

Avoid using python's print for Python 3.x compatibility
- print chanced from statement to a function in python 3, for our
  purposes sys.stdout.write() is sufficient and avoids dealing with
  the incompatibilities between Python 2.x and 3.x
- suggested by David Malcolm / Ville Skyttä

Unbreak lzdio/xzdio
- revert part of b0d1038190be5cb4b45e2c2c7c84ee7022164ba2 which broke
  the split-personality lzdio/xzdio

Skip posttrans scripts of failed transaction elements

Since we really want a FILE* then get one in the first place
- this is visible in the librpmbuild exported goo, rename the member
  to force build-breakage on the poor souls trying to use librpmbuild API

Use a helper function for finding fileno of specific io type
- also differentiate between lzdio and xzdio here

Lose unnecessary url type checking from fdSize()
- we're only dealing with local files once fd is opened

Lose unused leftover definitions

Eliminate ufdio-specific read, write, seek and close
- we dont do network IO anymore so ufdio only differs from fdio by
  downloading the file on open if necessary, after that it's just fdio

Use fd.tell() instead of going around through os.lseek() with fdno

Add tell() method to rpm.fd class

Add ftell() clone to FD_t

Avoid unnecessary dup'ing of file descriptors on header list operations
- convert to rpm.fd on python side already add use internal helper
  which only accepts rpm.fd type to avoid having to dup around on
  every item

Accept rpm.fd() types file objects everywhere in python bindings
- turn rpmfdFromPyObject() into a python-level object converter, add
  a separate C-level getter for the fd pointer itself
- take advantage of python refcounting to handle differences between
  native vs converted rpm.fd in callers so we can simply decref the
  rpmfdFromPyObject() result without having to worry whether it was
  converted or not (ie should we close it or not)

Make fdUpdateDigests() static now that its possible

Make FD_t struct opaque, finally

Eliminate last remaining FD_t struct privacy violation
- add getter for fd digest bundle, uninline the setter

Remove cpio stuff from FD_t
- only the FSM cares about cpio position, move it there - there's only
  ever one fd active inside FSM, no need to track it per-fd

Move debug goo defs to rpmio.c

Move pile of helpers from rpmio_internal.h to rpmio.c, remove unused stuff
- nothing outside rpmio.c needs these, make 'em static there
- uninlining reveals quite a few completely unused helpers...

Move fd statistics foo inside rpmio.c now that it can

Move fdDigest*() to rpmio.c where they better belong

Remove pointless inlining of stuff in rpmio

Use common "not implemented" implementation of Fseek()

Add first rough-cut python bindings for rpmio fd
- attempt to mimic python file object where possible, but nowhere near
  all methods are supported, either just not yet done or due to
  underlying limitations

Raise exception in the converter, not caller

Permit changing rpm.td tag from python

Add limited support for modifying headers to python
- for now we only support tag deletion and assigning rpmtd objects, limiting
  this to copying data from other headers

Fix format extension memleak on empty strings

Output dependency type on --requires etc queries if verbose (RhBug:528342)

Add RPMTAG_VERBOSE extension
- hack to permit different query formatting based on rpm's verbosity level

Permit conditional query formats on not yet cached data too

Oops, configuring wrong ts in rpm.ts() initialization

Move further initialization from python ts tp_new to tp_init
- lose the unnecessary rpmts_Wrap(), it's not needed and just gets
  in the way of things

Revert explicit PyErr_NoMemory() returns to just returning NULL
- tp_alloc failing is likely to be OOM but we dont know that for a fact,
  and the failing method is responsible for setting the exception

Handle NULL in ts get/setKeyring as python None

Kill off _rpmb.error exception type
- import of _rpmb messes up rpm.error to point to _rpmb.error which we
  do not want
- use ValueError for unparsable spec for now, need to figure something
  saner there still

Permit setting and getting ts keyring from python

Add bindings for rpm keyring and pubkey types

Add an interface to parse armored OpenPGP from memory
- refactor the decoding part out of pgpReadPkts() to separate helper,
  and add pgpParsePkts() around that

Support passing extra options to dep generator scripts

Lose unused python/perl/java stringbuffers from rpmfc

Bah, get the new ocaml-scripts into tarballs too
- should've been in commit 82e7dd702013d3679fda438333de30afdec17a4f

Python namespace import fiddling
- import rpm instead of _rpm for exception name compatibility
- import the lowlevel transaction class as _rpmts, makes it slightly
  easier to see which is which

Teach the internal dep generator about OCaml
- OCaml seems to have fairly well detectable magic in its files, nice
- Dont call the regular find-requires from the scripts now that internal
  is working

Add OCaml dependency generator scripts (Richard W.M. Jones)

Deprecate %__lzma, use %__xz in it.

Decompress lzma files with xz.

Improve perl.req here-doc skipping.

This version is stricter in finding the end identifier by using equality test
instead of a regex (as a side effect, fixes rhbz#524929) as well as parsing
quoted identifiers, and adds support for identifiers in backticks.

Delete ancient and defunc python test programs

Dont leak memory from rpm.fi() methods
- Py_BuildValue() always copies the data mallocing here is just wrong

Handle all rpmds variants in its constructor
- either it takes a header + tag, or (name, flags, version) tuple + tag
  to generate a single dep
- push rpm.dsSingle() compatibility out to python side
- hdr.dsFromHeader() and hdr.dsOfHeader() no longer need to be in rpmds-py.c

rpmdb open failing is certainly an rpm error, not TypeError

Dead code removal

Permit threads during rpmReadPackageFile()

Type mismatch is TypeError, not rpm.error

Push hdrFromFdno() error code handling over to python side
- return (rpmrc, header) tuple from C to let python do whatever it
  wishes with the information
- let python side worry about generating backwards compatible returns

Push hdrCheck() error code handling over to python side
- return (rpmrc, message) tuple from C to let python do whatever it
  wishes with the information
- let python side worry about generating backwards compatible returns

Teach python about the lowlevel RPMRC codes

Push ts.check() return tuple-o-doom generation over to python side

Teach python about RPMSENSE_ANY

Enable retrieving problem key from python too

Push transaction problem filter to python side
- make C-level ts.run() require ignoreSet just like the real one does
  and keep the value on python side of things

Push the interpretation of ts.run() result code to python side
- at least this lets sub-typers override the hysterical return values

Add minimal python wrapping for rpmProblem objects
- for now, only expose the basic attributes and return problem string
  representation on %s
- return problem objects on rpmps iteration

Ugh, forgot to add the new _rpmb module to git
- should've been in commit 8169bbde6934637ed7be58e18103330c1d5e4546

Push most work of ts.addErase() over to python
- minimize the stuff done in C: rpmtsAddEraseElement() only cares about
  header, so that's what we accept on C-level bindings
- on python side, handle db recno's and labels like we've always done,
  additionally accept match iterators and plain headers too

Return error code from rpmtsAddEraseElement() failure
- trying to remove non-installed header counts as an error

Permit file objects and file names to ts.addInstall()
- largely removes the need for the klunky ts.hdrFromFdno()

Push most work of ts.addInstall() over to python
- minimize the stuff done in C: require all arguments in final format
  and report status back with a boolean, handle everything else including
  keylist refcounting hack over to python side

Oops, missing self in bunch of calls... been too long since writing Python ;)

Push the rpmtsGetKeys() stuff over to python completely
- trivially implemented in python by iterating over transaction element
  keys, we dont need no stinking extra librpm APIs for this

Add rpmlog() wrapper to python bindings

Teach python about RPMDBI_LABEL

Split rpmbuild dependencies to separate _rpmb module
- installers and the like dont need the pile of poo called librpmbuild for
  anything, avoid dragging it in needlessly
- import _rpmb into rpm namespace if available but dont complain if
  its not there
- arrange ts.parseSpec() compatibility on python side by dynamically
  importing _rpmb if possible

Move ts flag & color setting to python side

Add a dummy python-level transaction set class, use it always
- move the rpm.ts() vs rpm.TransactionSet() compatibility to python
- this will enable doing only the lowest level stuff in C and rest
  in python

Add python method for retrieving header "instance" (db recno) number

Deprecation tweaks
- use PyErr_WarnEx() for better control and leave the tracking up to python
- use PendingDeprecationWarning for now
- document the replacing functionality in the deprecation messages
- make hdr.sprintf() just an alias to hdr.format() without deprecating,
  at least for now it'd be only a gratuitous incompatible change on python side

Oops, these are mappings, not dicts...

Generalize python ts flags and colors set/get foo
- make flags, vsflags, color, prefcolor (previously not available)
  and probFilter appear as internal attributes of ts objects, each
  with their own setter/getter methods
- make the old custom set/get methods access the internal attributes instead
- keeping them "internal only" leaves room for adding further sanity
  checking and nicer interface on python side while giving direct access
  bits for those who want it
- not deprecating the old get/set methods at least yet...

Fix couple of recently introduced compiler warnings

Include structmembers.h centrally from rpmsystem-py.h
- pretty much everything might need this...

Add API for setting preferred transaction file color
- not strictly needed as it gets its default from a macro but .. shrug

Make python ts rootDir appear as a read-only attribute
- there's no need to change the rootdir after object creation, better
  not permit at all

Add python getter for transaction id

Eliminate python ts scriptFd kludgery
- make the scriptFd appear as regular attribute by providing a setter
  method for it, permit any file object to be used and allow disabling too
- readonly for now as we dont have rpmfd wrapped yet
- remove now unnecessary custom get/setattr functions

Deprecate custom foo.count() methods, support len() instead

Eliminate unused python ts iterator filter stuff
- iterators dont take arguments so there's no convenient way to filter
  while iterating, let python users filter themselves (like they've
  always been doing)

Take advantage of headerNextTag() in python hdr.keys()
- avoids whole lotta unnecessary copying of data, we're only interested
  in tag numbers here
- dont filter out stuff - python consumers can look at i18n data too

Add iterator support to python header objects

Add alternative header iterator method
- we dont always want the actual contents of the tag to be copied
  on iteration, so add an interface that returns the next tag in the
  header
- this lets callers to decide what to do with the tag and how to
  retrieve it

Add some flags to rpmtd creation
- permit disabling extension retrieval and "raw" (untranslated i18n) tags
- always use HEADERGET_ALLOC for data availability sanity

Add beginnings of rpmtd wrappings to python
- unlike other types, store the C-level td structure directly in the
  python object, this lets us selectively expose some members directly,
  avoids having to deal with rpmtd allocation separately and as leaves
  the reference counting to python as rpmtd's aren't refcounted on C-level

Turn hdrGetHeader() into argument parsing converter interface

Sanitize getattr behavior of header objects
- when generic getattr fails, only try retrieving header tag as attribute
  if it's a valid tag
- clear any python errors if generic getattr failed
- split generating a python object from header + tag to an internal helper

Require expected type in PyArg_ParseTupleAndKeywords() already

Support numeric expansion in rpm.expandMacro()

Push rpm.signalsCaught() to python level
- only implement the bare minimum in C by adding a thin wrapper for
  rpmsqIsCaught(), the rest can easily be done in python

Implement rpm.readHeaderFromFD() in python instead of C