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

Implement rpm.readHeaderListFromFD() in python instead of C

Implement rpmreadHeaderListFromFile() in python instead of C

A few cases of Py_RETURN_NONE missed on the first round

Arrange rpm.headerLoad() compatibility on python level

OSGi dependency generator fixes from Alphonse Van Assche (ticket #101)
- This patch fix some minor bug, remove unused code and increase drastically
  the perf by threading execution of tasks and using zip command instead of
  jar to get meta-data

Enable subtyping on the rest of our type-objects
- not very useful atm as various places return hard-wired built-in types

Eliminate all custom tp_free() type methods
- tp_free()'s purpose is only to free up the memory used by the python
  object structure, cleaning up our own allocations belongs to tp_dealloc()

Enable subtyping on rpm.ts class

Call generic python setattr if not scriptFd
- yet more preliminaries for subtyping

tp_setattro() is supposed to return -1 on errors

Call (sub)type tp_free from destructors
- more preliminaries for subtyping
- remove pointless NULL checks

Make object allocation type agnostic
- pass (sub)type down to wrappers
- call subtype tp_alloc() instead of PyObject_New()
- preliminaries for allowing subtyping

Remove unnecessary header type checking
- the type is already validated by PyArg_ParseTupleAndKeywords(),
  no need to doublecheck

Remove the broken tp_print method from spec

Decouple python spec objects from transaction objects
- ts structure is only necessary for hysterically passing back the
  parse result from parseSpec(), hide this in the bindings
- deprecate ts.parseSpec() for later ripping

Oops, binary data can and should be presented as python strings

Add rpmtd to python object converter, change header code to use that
- vastly simpler than the former goo in hdr_subscribe

Turn tagNumFromPyObject() into an object converter interface
- permits direct validation and conversion from arg parsing

Turn rpmFdFromPyObject() into an object converter interface
- permits direct validation and conversion from arg parsing

Permit any file object in rpm.readHeaderListFromFD()

Permit file objects in python header constructor

Add write() method to python headers

Accept any file object in ts.hdrFromFdno()

Add helper to convert python file objects to rpmio FD_t type

Add te.NEVRA() method, adjust docs

Remove tp_print methods from all rpm-python objects
- these violate the intended use of tp_print, python docs state
  "A type should never implement tp_print in a way that produces
  different output than tp_repr or tp_str would."

Lose the debug junk from python bindings

Add hdr.format(), deprecate hdr.sprintf()
- sprintf() is a C'ism and format() is closer to current librpm anyway

Make fiFromHeader() static inside header-py, deprecate

Deprecate rpm.headerLoad()
- this is not needed now, just call rpm.hdr(<blob) to load

Deprecate header filelist munging methods
- hdr.convert() is the generic way, the old stuff is not needed anymore
- macro to issue warnings just once

Eliminate unnecessary function

Permit headerConvert() from python

Add has_key() method to header object

Add support for creating new header objects
- without arguments, rpm.hdr() creates an empty header
- with another header as argument, make a copy
- string argument is considered an unloaded header blob and copy-loaded

Rpm's allocators dont return on OOM, remove unnecessary check

Add type checking macros for all rpm python type objects

Rename python system.h for disambiguation

Lose the empty doxygen markers
- nothing wrong with comments but empty comment placeholders
  are not exactly useful

Put some consistency to python object creation
- all type object creation goes through foo_Wrap() which handle OOM
  and all type specific initialization

Make all python object creation wrappers return PyObject pointers
- this way the only place where casts are needed are in the wrapper itself

Dont leak memory on rpm.ds iteration

Lose unnecessary next() methods
- python adds next() methods for objects supporting iterators

All rpm-python iterators are self-iterators, just use PyObject_SelfIter

Dont leak memory from rpm.dsSingle()

Simplify fiFromHeader()
- just call the fi object, no need to manually redo all this stuff

Simplify dsFromHeader()
- just call the ds object, no need to manually redo all this stuff

Sanitize python object -> tag number exception handling
- raise exception in tagNumFromPyObject(), not in 12 different callers
- check against RPMTAG_NOT_FOUND consistently instead of -1 and whatnot
- unknown tags are value, not key or type errors

Move allocations out of rpmps object init method
- tp_init can be called several times, allocating from there leaks memory
- tp_init gets called automatically on object creation, dont call manually
- nothing to initialize for rpmps...

Move allocations out of rpmds object init method
- tp_init can be called several times, allocating from there leaks memory
- tp_init gets called automatically on object creation, dont call manually