How can I handle version versions of Python packages without relying on SCM?

Question

One of the problems encountered during the development of Pinax is related to external application versions. I am trying to come up with a solution that is not related to the implementation of version control systems. The reason is that I would prefer not to install all possible version control systems in my system (or use them for authors) and solve problems that may arise when creating the environment.

Take this situation (knowing how Pinax works will be helpful to understand):

We are starting to develop a new version of Pinax. In the previous version, there is a file of requirements for applications with explicit versions. Error for an external application that we would like to solve. To fix this error in Pinax, the current process is simply to make a small version of the application, assuming we are in control of the application. Applications in which we have no control, we just consider the release cycle of the author of the application or force them to create releases ;-) I do not like to constantly release small issues for bug fixes, because in some cases I would like to be working on new features for applications . Of course, branching the old version is what we do and then do backports as needed.

I would like to hear some thoughts on this.

Answer 1

I would like to mention that the solution that I considered before asking him was to install PyPI Pinax and make development releases on it. We could put a copy of Hirosh. We already use pip -find links to point to pypi.pinaxproject.com for packages that we had to free.

Answer 2

Could you handle this with the version specifier "== dev"? If the distribution page on PyPI has a link to the .tgz of the current version of dev (for example, both github and bitbucket automatically), and you add the link "# egg = project_name-dev" to the link, both easy_install and pip will use this .tgz if requested == dev.

It doesn’t allow you to connect to something more specific than the “most recent tip / head”, but in many cases it can be good enough?

Answer 3

Most open source distributors (Debians, Ubuntu, MacPorts, etc.) use some kind of patch management mechanism. So, something like: import the basic source code for each package, as released, as a tarball, or as an SCM snapshot. Then make any necessary changes on top of it using the patch manager, such as quilt or Mercurial Queues . Then combine each external package with any application fixes in a consistent format. Or have the URLs of the base packages and URLs for individual patches and apply them during installation. What is essential is what MacPorts does.

EDIT: to take this one step further, you could then manage the version of the patches in all external packages and make them available as a whole. This is pretty easy to do with Mercurial Queues. Then you simplified the problem only for publishing one set of patches using the same SCM system with patches applied locally as described above, or for developers to pull out and apply basic release packages to their copies.

Answer 4

EDIT: I'm not sure I'm reading your question correctly, so the following may not answer your question directly.

Something that I reviewed but have not tested uses the patch-freeze function. Perhaps using this and distributing the package with Pinax will work? My only concern is how different OSs are handled. For example, I never used pip on Windows, so I did not know how the package would interact there.

The idea I'm hoping to try is to create a script stacker that controls package management, which will make it easier for users to upgrade to newer versions. This will require some scaffolding.

Another option may be that you keep a mirror of applications that you do not control in consistent vcs, and then distribute your mirrored versions. This will remove the need for “everyone” to have many different programs.

Other than that, it seems the only real solution is what you guys do, there is no way I could find.