by adding from_cpython/setup.py.

This way we can build _multiprocessing as a shared module to be
loaded on-demand, since it's quite expensive right now for us to
import it.

CPython has a similar setup.py, but theirs is pretty large (2kloc)
so I don't feel like we need to try copying yet.

We could/should move other modules to use this strategy.

I'm not 100% happy with the build system support, but we can iterate
on that.

For weakly-referenced objects that are garbage, we end up freeing their
attributes within that collection (assuming they are garbage as well).
This means that these objects are in a state that is not quite dead (we
don't want to allocate anything else in that space and clobber their
weakreflist), and not quite alive (their attributes point to garbage
memory).

So, change the handling to finish looking at those objects in the collection
that they become garbage, and then free them to make them properly dead.

weakrefs-handling is unavoidably reentrant, but now we only have to worry
about fully-dead (the referents) or fully-alive (the weakrefs) objects.

(pickle does this)

attrwrapper.iteritems also need to return an iterator (previously, a list)
since pickle calls next on those directly as well.

Our initialization is a bit different from CPython's, and multiprocessing
seems pretty sensitive to that.

So initialize it in a different place than we load the rest of the builtin
modules.

Some of the functionality relies on ctypes so it doesn't work, but it looks
like ctypes doesn't get imported until you try to use those features.

misc library work

Paste kind of uses it.

It might also be ok to just have it throw an ImportError()

This gets pycurl and PIL working.

Unfortunately I can't figure out a great way to test this; pycurl
has external dependencies, and PIL only works with some workarounds
that I don't want to check in.  I think these features are
innoccuous enough that it's worth getting these in.

Surprisingly, setting tp_getattr and tp_getattro have pretty different behavior;
we can kind of make tp_getattro work with subclassing but apparently don't
do very will with tp_getattr.

Punt on fixing that for now and switch thread._local to use getattro

Class slot handling is getting pretty messy

Don't pass path to this version of find_module (unlike finders in meta_path).

Implement built-in input() function.

Fewer StopIteration exceptions

Add support for METH_OLDARGS and list.pop(long)

the tpp_hasnext/__hasnext__ changes require us to be able to __call__ descriptors for wrapped pyston methods.  this shouldn't be a problem, though, at least for tpp_hasnext

also advance generators in __hasnext__ so we can return false instead of throwing StopIteration if the generator exits.

Update virtualenv to a version which removes a lot of old pyston specific hacks

Sqlalchemy tests2

We would keep on adding the same object to the weakrefs list,
which would eventually trigger a collection, and cause all sorts
of weird things to happen.

This isn't just a performance optimization, but is actually important
since people put things in dicts that don't __eq__ themselves.
The common example (and test here) is NaN, but in particular sqlalchemy
does this with clauses (where __eq__ returns a new sql clause).

Also, handle cases that __eq__ returns non-bool

And add set.difference_update() and set.isdisjoint()

Using their test runner is quite hard since it tries to override a lot
of basic functionality (ex for enhanced tracebacks).  So just do some
manual test discovery, and only run the tests that cpython can pass
using this setup.

We still fail a couple more though.

Clean up the BoxedTuple class

Fix "sys.excepthook is missing" warnings

Add more imp.* functions, set correct module.__file__, import * with non module globals

Get `cpython/test_property.py` to pass

by adding sys.excepthook.