Reorganize to provide pure-Python wrappers around C++ functions/objects?

[a-hurst]

As a long-time aggdraw user (and contributor!) I've always been a little annoyed that things like docstrings and API hints in IDEs don't work correctly with the package because it's a pure C++ module. Rewriting in Cython has been proposed (and would be much easier to maintain I'm sure), but that's a big undertaking with a lot of potential for breaking compatibility!

As I was doing some aggdraw stuff the other day I thought of a potential simpler solution: instead of rewriting the Aggdraw C++ code itself, simply migrate it into a module inside of a traditional Python package layout and then write some thin wrapper functions around all classes & functions in pure Python that internally calls the C++ stuff. For example, instead of exporting the C++ created Pen() object to the user directly, have a Pen() class in Python instead that internally creates a C++ Pen() instance and exposes its attributes with getters.

Imagining something like this:

class Draw(object):

    def __init__(self, image_or_mode, size=None, color=WHITE):
        if size:
            self._draw = aggdraw.cpp.Draw(image_or_mode, size, color)
        else:
            self._draw = aggdraw.cpp.Draw(image_or_mode)

    def arc(self, xy, start, end, pen=None):
        self._draw.arc(xy, start, end, pen)

The user-facing API should be able to stay the exact same, so it should be possible to migrate to this sort of setup without breaking backwards compatibility. Would also allow for things like better type checking too. It might take a while for me to find time, but if you're interested I could try putting together a proof-of-concept PR. Let me know what you think!

Relevant to #72 and #43.

[djhoese]

I like this as a half-way point to the Cython solution. I think the best way to do this would be how you described and keep as little in the Python code as possible for now. Docstrings can mostly be copied from the C++. It'd also be nice (and required I think) to make an aggdraw package where cpp.cpp (or cpp_wrapper.cpp?) would live. Then setup.py just needs to be updated to point to the right things. This does break the over-the-top #113 PR, but it might be worth it. We can't one PR hold back the rest of the project.

And alternative, but similar approach would be instead of your Python code in a python module, put it in a Cython module. So there's the C++ as-is, there's a cython module that imports/includes it, and that's all in the package. Gives a little more control perhaps...hm but I'm not sure how well IDEs like Cython-based type hints. We could also do Python-based Cython (a python module with Cython types and annotations) but I've never been a fan of it.