Use of GPLed Python extension modules

[Patrick Maupin]

Andreas Kostyrka wrote:

> Well, the big "difference" between C libraries, and Python modules is
> that C libraries usually consist of .h files, which get included in
> your "dynamically" linked program. That wouldn't be that bad, but .h
> files often contain macros and/or inlined function, which makes every
> client of the library include some part of the sourcecode of the
> library.
> 
> Python modules OTOH include only my name, so there is no "code"
> leaked into my program.
> 
> If you read the interviews of the FSF Lawyers with this in your head,
> it just makes much more sense (yeah, by using readline you are
> including it, well at least parts, in your program).

Well, that does make it read a bit more sensibly, but that is not
really what they are saying.  The GPL FAQ on the FSF site talks
about dynamically interpreted languages, and even states very
explicitly that "A consequence is that if you choose to use
GPL'd Perl modules ... you must release the program in a GPL-
compatible way."

As another example, the email exchange leading up to the
GPLing of clisp is quite instructive.  Personally, I don't find
"my lawyer made me do it" particularly compelling, especially
since that was tried after "but if I let _you_ do it, then
_anybody_ can get away with it" but I suppose it _could_ have
happened that way:

http://cvs.sourceforge.net/viewcvs.py/*checkout*/clisp/clisp/doc/Why-CLISP-is-under-GPL?rev=HEAD

It may be true, as Daniel Berlin opines, that the FSF would have some
chance of convincing a judge of the correctness of this position.

However, the copying of small interface portions necessary for
interoperability has been ruled in some cases to be "fair use".
Even if you were worried that this was an issue, you could, in
a few hours, engineer a "clean-room" implementation of the header
files.  This would involve someone reading them, describing in his
own words  the bare minimum that was necessary to reconstruct an
interoperable .h file, and passing this description to someone
else to reimplement.

As you pointed out, Python's dynamicity makes not using the original
source even easier.  This is true in some cases even if the GPLed
library is in C -- you might be able to interface with it via calldll,
and not even use any .h file description of the program in your
system.

But, as the GPL FAQ makes clear, and as many other of Stallmans'
writings make clear, in the opinion of at least some at the FSF
you would be violating the GPL if you were to do this.  As I have
posted elsewhere, I have read several things which indicate that
this may not be true (at least if you are not actually distributing
the GPLed software along with your program).  The only things I
have seen which indicate that it may be true are Richard Stallman
saying that it's true (without giving a good deep explanation why)
and other people saying "Well, of _course_ it's true!  The GPL FAQ
says so!"

As long as everybody (probably correctly) agrees that it's not
worth it to provoke the FSF, then it doesn't really matter to
the FSF whether their position is legally defensible or not, because
obviously their position is having the desired effect if nobody
wants to test it in a courtroom.  The reality that some people
are running scared of the "viral" nature of the GPL is actually
viewed as beneficial by Stallman and others who aren't busy trying
to get work done with both free and non-free software in a corporate
environment complete with conservative lawyers and bosses.

Pat