FAQ
Hi folks,


currently, I came across http://pythonwheels.com/ during researching how
to make a proper Python distribution for PyPI. I thought it would be
great idea to tell other maintainers to upload their content as wheels
so I approached a couple of them. Some of them already provided wheels.


Happy being able to have built my own distribution, I discussed the
issue at hand with some people and I would like to share my findings and
propose some ideas:


1) documentation is weirdly split up/distributed and references old material
2) once up and running (setup.cfg, setup.py etc. etc.) it works but
everybody needs to do it on their own
3) more than one way to do (upload, wheel, source/binary etc.) it (sigh)
4) making contact to propose wheels on github or per email is easy
otherwise almost impossible or very tedious
5) reactions went evenly split from "none", "yes", "when ready" to "nope"


None: well, okay
yes: that's good
when ready: well, okay
nope: what a pity for wheels; example:
https://github.com/simplejson/simplejson/issues/122


I personally find the situation not satisfying. Someone proposes the
following solution in form of a question:


Why do developers need to build their distribution themselves?


I had not real answer to him, but pondering a while over it, I found it
really insightful. Viewing this from a different angle, packaging your
own distribution is actually a waste of time. It is a tedious,
error-prone task involving no creativity whatsoever. Developers on the
other hand are actually people with very little time and a lot of
creativity at hand which should spend better. The logical conclusion
would be that PyPI should build wheels for the developers for every
python/platform combination necessary.




With this post, I would like raise awareness of the people in charge of
the Python infrastructure.




Best,
Sven

Search Discussions

  • Matthias Bussonnier at Sep 6, 2015 at 6:29 pm
    Hi Sven,


    Just adding a few comments inline:


    On Sun, Sep 6, 2015 at 7:33 PM, Sven R. Kunze wrote:

    3) more than one way to do (upload, wheel, source/binary etc.) it (sigh)

    And most are uploading/registering over http (sight)

    nope: what a pity for wheels; example:
    https://github.com/simplejson/simplejson/issues/122

    But that's for non pure-python wheels,
    wheel can be universal, in which case they are easy to build.

    Why do developers need to build their distribution themselves?

    Historical reason. On GitHub, at least it is pretty easy to make Travis-CI
    build your wheels, some scientific packages (which are not the easier to build)
    have done that, so automation is possible. And these case need really
    particular environements where all aspects of the builds are controlled.

    I had not real answer to him, but pondering a while over it, I found it
    really insightful. Viewing this from a different angle, packaging your own
    distribution is actually a waste of time. It is a tedious, error-prone task
    involving no creativity whatsoever. Developers on the other hand are
    actually people with very little time and a lot of creativity at hand which
    should spend better. The logical conclusion would be that PyPI should build
    wheels for the developers for every python/platform combination necessary.

    I think that some of that could be done by warehouse at some point:
    https://github.com/pypa/warehouse


    But you will never be able to cover all. I'm sure people will ask PyPI
    to build for windows 98 server version otherwise.


    Personally for pure python packages I know use https://pypi.python.org/pypi/flit
    which is one of the only packaging tools for which I can remember all the
    step to get a package on PyPI without reading the docs.


    --
    M


    [Sven, sorry for duplicate :-) ]
  • Terry Reedy at Sep 6, 2015 at 7:31 pm

    On 9/6/2015 1:33 PM, Sven R. Kunze wrote:
    Hi folks,

    currently, I came across http://pythonwheels.com/ during researching how
    to make a proper Python distribution for PyPI. I thought it would be
    great idea to tell other maintainers to upload their content as wheels
    so I approached a couple of them. Some of them already provided wheels.

    Happy being able to have built my own distribution, I discussed the
    issue at hand with some people and I would like to share my findings and
    propose some ideas:

    1) documentation is weirdly split up/distributed and references old
    material
    2) once up and running (setup.cfg, setup.py etc. etc.) it works but
    everybody needs to do it on their own
    3) more than one way to do (upload, wheel, source/binary etc.) it (sigh)
    4) making contact to propose wheels on github or per email is easy
    otherwise almost impossible or very tedious
    5) reactions went evenly split from "none", "yes", "when ready" to "nope"

    None: well, okay
    yes: that's good
    when ready: well, okay
    nope: what a pity for wheels; example:
    https://github.com/simplejson/simplejson/issues/122

    I personally find the situation not satisfying. Someone proposes the
    following solution in form of a question:

    Why do developers need to build their distribution themselves?

    I had not real answer to him, but pondering a while over it, I found it
    really insightful. Viewing this from a different angle, packaging your
    own distribution is actually a waste of time. It is a tedious,
    error-prone task involving no creativity whatsoever. Developers on the
    other hand are actually people with very little time and a lot of
    creativity at hand which should spend better. The logical conclusion
    would be that PyPI should build wheels for the developers for every
    python/platform combination necessary.


    With this post, I would like raise awareness of the people in charge of
    the Python infrastructure.

    pypa is in charge of packaging. https://github.com/pypa
    I believe the google groups link is their discussion forum.


    --
    Terry Jan Reedy
  • Laura Creighton at Sep 6, 2015 at 7:54 pm

    In a message of Sun, 06 Sep 2015 15:31:16 -0400, Terry Reedy writes:
    On 9/6/2015 1:33 PM, Sven R. Kunze wrote:

    With this post, I would like raise awareness of the people in charge of
    the Python infrastructure.
    pypa is in charge of packaging. https://github.com/pypa
    I believe the google groups link is their discussion forum.

    They have one -- https://groups.google.com/forum/#!forum/pypa-dev
    but you can also get them at the disutils mailing list.
    https://mail.python.org/mailman/listinfo/distutils-sig


    I think, rather than discussion, it is 'people willing to write code'
    that they are short of ...


    Laura
  • Mark Lawrence at Sep 6, 2015 at 8:03 pm

    On 06/09/2015 20:31, Terry Reedy wrote:
    On 9/6/2015 1:33 PM, Sven R. Kunze wrote:
    With this post, I would like raise awareness of the people in charge of
    the Python infrastructure.
    pypa is in charge of packaging. https://github.com/pypa
    I believe the google groups link is their discussion forum.

    Or gmane.comp.python.pypa.devel


    --
    My fellow Pythonistas, ask not what our language can do for you, ask
    what you can do for our language.


    Mark Lawrence
  • Ned Batchelder at Sep 6, 2015 at 8:06 pm

    On Sunday, September 6, 2015 at 1:33:58 PM UTC-4, Sven R. Kunze wrote:
    Why do developers need to build their distribution themselves?

    ...

    With this post, I would like raise awareness of the people in charge of
    the Python infrastructure.

    Sven, you ask a question, and then say you are trying to raise awareness.
    Are you making a proposal? It sounds like you might be implying that it
    would be better if some central infrastructure group could make all the
    distributions?


    As a developer of a Python package, I don't see how this would be better.
    The developer would still have to get their software into some kind of
    uniform configuration, so the central authority could package it. You've
    moved the problem from, "everyone has to make wheels" to "everyone has to
    make a tree that's structured properly." But if we can do the second
    thing, the first thing is really easy.


    Maybe I've misunderstood?


    --Ned.
  • Sven R. Kunze at Sep 7, 2015 at 4:52 pm

    On 06.09.2015 22:06, Ned Batchelder wrote:
    As a developer of a Python package, I don't see how this would be better.
    The developer would still have to get their software into some kind of
    uniform configuration, so the central authority could package it. You've
    moved the problem from, "everyone has to make wheels" to "everyone has to
    make a tree that's structured properly." But if we can do the second
    thing, the first thing is really easy.
    Unfortunately, I disagree with you one that and others already gave
    explanations why.




    Internally, we had this "wild-west" tree in our source as well but we
    moved on to a properly structured tree and it solved problems we didn't
    even imagine to have solved when starting this effort some years ago.




    Best,
    Sven
  • Ryan Gonzalez at Sep 7, 2015 at 1:22 am

    On September 6, 2015 12:33:29 PM CDT, "Sven R. Kunze" wrote:
    Hi folks,

    currently, I came across http://pythonwheels.com/ during researching
    how
    to make a proper Python distribution for PyPI. I thought it would be
    great idea to tell other maintainers to upload their content as wheels
    so I approached a couple of them. Some of them already provided wheels.

    Happy being able to have built my own distribution, I discussed the
    issue at hand with some people and I would like to share my findings
    and
    propose some ideas:

    1) documentation is weirdly split up/distributed and references old
    material
    2) once up and running (setup.cfg, setup.py etc. etc.) it works but
    everybody needs to do it on their own
    3) more than one way to do (upload, wheel, source/binary etc.) it
    (sigh)
    4) making contact to propose wheels on github or per email is easy
    otherwise almost impossible or very tedious
    5) reactions went evenly split from "none", "yes", "when ready" to
    "nope"

    None: well, okay
    yes: that's good
    when ready: well, okay
    nope: what a pity for wheels; example:
    https://github.com/simplejson/simplejson/issues/122

    I personally find the situation not satisfying. Someone proposes the
    following solution in form of a question:

    Why do developers need to build their distribution themselves?

    I had not real answer to him, but pondering a while over it, I found it

    really insightful. Viewing this from a different angle, packaging your
    own distribution is actually a waste of time. It is a tedious,
    error-prone task involving no creativity whatsoever. Developers on the
    other hand are actually people with very little time and a lot of
    creativity at hand which should spend better. The logical conclusion
    would be that PyPI should build wheels for the developers for every
    python/platform combination necessary.

    You can already do this with CI services. I wrote a post about doing that with AppVeyor:


    http://kirbyfan64.github.io/posts/using-appveyor-to-distribute-python-wheels.html


    but the idea behind it should apply easily to Travis and others. In reality, you're probably using a CI service to run your tests anyway, so it might as well build your wheels, too!

    With this post, I would like raise awareness of the people in charge of

    the Python infrastructure.


    Best,
    Sven
    _______________________________________________
    Python-ideas mailing list
    Python-ideas at python.org
    https://mail.python.org/mailman/listinfo/python-ideas
    Code of Conduct: http://python.org/psf/codeofconduct/

    --
    Sent from my Nexus 5 with K-9 Mail. Please excuse my brevity.

Related Discussions

Discussion Navigation
viewthread | post
Discussion Overview
grouppython-list @
categoriespython
postedSep 6, '15 at 5:33p
activeSep 7, '15 at 4:52p
posts8
users7
websitepython.org

People

Translate

site design / logo © 2019 Grokbase