## The Situation
I’m trying to port an open-source library to Python 3.  ([SymPy][1], if anyone is wondering.) 

So, I need to run `2to3` automatically when building for Python 3. To do that, I need to use `distribute`. Therefore, I need to port the current system, which (according to the doctest) is `distutils`. 

&lt;br&gt;

## The Problem
Unfortunately, I’m not sure what’s the difference between these modules—`distutils`, `distribute`, `setuptools`. The documentation is sketchy as best, as they all seem to be a fork of one another, intended to be compatible in most circumstances (but actually, not all)…and so on, and so forth. 

&lt;br&gt;

## The Question
**Could someone explain the differences?** What am I supposed to use?  What is the most modern solution? (As an aside, I’d also appreciate some guide on porting to `Distribute`, but that’s a tad beyond the scope of the question…)


  [1]: http://sympy.org/ &quot;SymPy&quot;

Differences between distribute, distutils, setuptools and distutils2?

How do I make `setup.py` include a file that isn&#39;t part of the code? (Specifically, it&#39;s a license file, but it could be any other thing.)

I want to be able to control the location of the file. In the original source folder, the file is in the root of the package. (i.e. on the same level as the topmost `__init__.py`.) I want it to stay exactly there when the package is installed, regardless of operating system. How  do I do that?

Including non-Python files with setup.py

Python has a confusing history of tools that can be used to package and describe projects: these include `distutils` in the Standard Library, `distribute`, `distutils2`, and `setuptools` (and maybe more). It appears that `distribute` and `distutils2` were discontinued in favor of `setuptools`, which leaves two competing standards.

To my understanding `setuptools` offers far more options (e.g. declaring dependencies, tests, etc.) than `distutils`, however it is not included in the Python standard library (yet?).

The *Python Packaging User Guide*[[1]] recommends now:

&gt; Use `setuptools` to define projects and create Source Distributions.

And explains:

&gt; Although you can use pure `distutils` for many projects, it does not support defining dependencies      on other projects and is missing several convenience utilities for automatically populating package  metadata correctly that are provided by `setuptools`. Being outside the standard library, setuptools  also offers a more consistent feature set across different versions of Python, and (unlike `distutils`), `setuptools` will be updated to produce the upcoming “Metadata 2.0” standard formats on all supported versions.
&gt;
&gt;Even for projects that do choose to use `distutils`, when pip installs such projects directly from source (rather than installing from a prebuilt wheel file), it will actually build your project using `setuptools` instead.

However, looking into various project&#39;s *setup.py* files reveals that this does not seem to be an actual standard. Many packages still use `distutils` and those that support `setuptools` often mix `setuptools` with `distutils` e.g. by doing a fallback import:

    try:
        from setuptools import setup
    except ImportError:
        from distutils.core import setup

Followed by an attempt to find a way to write a setup that can be installed by both `setuptools` and `distutils`. This often includes various ways of error-prone dependency checking, since `distutils` does not support dependencies in the setup function.

Why are people still making the extra effort to support `distutils` - is the fact that `setuptools` is not in the standard library the only reason? What are the advantages of `distutils` and are there any drawbacks of writing *setup.py* files that only support `setuptools`. 

[1]:https://packaging.python.org/guides/tool-recommendations/

setuptools vs. distutils: why is distutils still a thing?

When using setuptools, I can not get the installer to pull in any [`package_data`][1] files. Everything I&#39;ve read says that the following is the correct way to do it. Can someone please advise?

    setup(
       name=&#39;myapp&#39;,
       packages=find_packages(),
       package_data={
          &#39;myapp&#39;: [&#39;data/*.txt&#39;],
       },
       include_package_data=True,
       zip_safe=False,
       install_requires=[&#39;distribute&#39;],
    )

where ``myapp/data/`` is the location of the data files.


  [1]: https://pythonhosted.org/setuptools/setuptools.html#including-data-files

How to include package data with setuptools/distutils?

I&#39;ve just started working with setuptools and virtualenv. My package requires the latest python-gearman that is only available from GitHub. The python-gearman version that&#39;s on PyPI is an old one. The Github source is setuptools-compatible, i.e. has setup.py, etc. Is there a way to make setuptools download and install the new version instead of looking for it on PyPI and installing the old one?

FYI, the new python-gearman is http://github.com/mtai/python-gearman

How can I make setuptools install a package that&#39;s not on PyPI?

I&#39;ve been usually installed python packages through pip.

For Google App Engine, I need to install packages to another target directory.

I&#39;ve tried:

&gt; pip install -I flask-restful --target ./lib

but it fails with:

&gt; must supply either home or prefix/exec-prefix -- not both

How can I get this to work?

DistutilsOptionError: must supply either home or prefix/exec-prefix -- not both

Does anybody encounter this warning when executing `python setup.py install` of a PyPI package?

`install_requires` defines what the package requires. A lot of PyPI packages have this option. How can it be an &quot;unknown distribution option&quot;?

pypi UserWarning: Unknown distribution option: &#39;install_requires&#39;

I was trying to install Python packages a system I recently gained access to. I was trying to take advantage of Python&#39;s relatively new [per user site-packages directory][1], and the new option `--user`. (The option is [currently undocumented][2], however it exists for Python 2.6+; you can see the help by running `python setup.py install --help`.)

When I tried running

    python setup.py install --user

on any package I downloaded, I always got the following error:

    error: can&#39;t combine user with with prefix/exec_prefix/home or install_(plat)base

The error was extremely perplexing because, as you can see, I wasn&#39;t providing the `--prefix`, `--exec-prefix`, `--install-base`, or `--install-platbase` flags as command line options. I wasted a lot of time trying to figure out what the problem was. I document my answer below, in hopes to spare some other poor soul a few hours of [yak shaving][3].


  [1]: http://docs.python.org/whatsnew/2.6.html#pep-370-per-user-site-packages-directory
  [2]: http://bugs.python.org/issue10745
  [3]: http://en.wiktionary.org/wiki/yak_shaving

Combine --user with --prefix error with setup.py install

I&#39;m trying to compile a python extension with cython in win 7 64-bit using mingw (64-bit).  
I&#39;m working with Python 2.6 (Active Python 2.6.6) and with the adequate distutils.cfg file (setting mingw as the compiler)


When executing

    &gt; C:\Python26\programas\Cython&gt;python setup.py build_ext --inplace

I get an error saying that gcc has not an -mno-cygwin option:

    &gt; C:\Python26\programas\Cython&gt;python setup.py build_ext --inplace
    running build_ext
    skipping &#39;hello2.c&#39; Cython extension (up-to-date)
    building &#39;hello2&#39; extension
    C:\mingw\bin\gcc.exe -mno-cygwin -mdll -O -Wall -IC:\Python26\include -IC:\Python26\PC -c hello2.c -o build\temp.win-amd64-2.6\Release\hello2.o
    gcc: error: unrecognized command line option &#39;-mno-cygwin&#39;
    error: command &#39;gcc&#39; failed with exit status 1


gcc is:

    C:\&gt;gcc --version
    gcc (GCC) 4.7.0 20110430 (experimental)
    Copyright (C) 2011 Free Software Foundation, Inc.

How could I fix it?




Compiling with cython and mingw produces gcc: error: unrecognized command line option &#39;-mno-cygwin&#39;

I just got some space on a VPS server(running on ubuntu 8.04), and I&#39;m trying to install django on it. The server has python 2.5 installed, but I guess its non standard installation. When I run install script for django, I get
  
    amitoj@ninja:~/Django-1.2.1$ python setup.py install
    Traceback (most recent call last):
      File &quot;setup.py&quot;, line 1, in &lt;module&gt;
        from distutils.core import setup
    ImportError: No module named distutils.core

I&#39;m stumped. All the articles on internet tell me how to install modules using distutils. But how do I get distutils itself? Can anyone point me to the archive for distutils? I looked in /usr/lib/local/python2.5, /usr/lib/python2.5 etc, and as expected there is no distutils to be found. 

how to install python distutils

Here&#39;s my stripped-down setup.py script with non-code stuff removed:


    #!/usr/bin/env python
    
    from distutils.core import setup
    from whyteboard.misc import meta
    
    
    setup(
        name = &#39;Whyteboard&#39;,
        version = meta.version,

        packages = [&#39;whyteboard&#39;, &#39;whyteboard.gui&#39;, &#39;whyteboard.lib&#39;, &#39;whyteboard.lib.pubsub&#39;,
                    &#39;whyteboard.lib.pubsub.core&#39;, &#39;whyteboard.lib.pubsub.utils&#39;, &#39;whyteboard.misc&#39;],
    
        py_modules = [&#39;whyteboard&#39;],
        scripts = [&#39;whyteboard.py&#39;],
    )





MANIFEST.in:

    include *.txt
    include whyteboard-help/*.*
    recursive-include locale *.mo
    recursive-include images *.png


When I run &quot;python setup.py install sdist&quot; I get a nice .tar.gz with a &quot;whyteboard-0.41&quot; root folder, with my locale/ images/ and whyteboard-help/ folders inside. This also has my whyteboard.py script that launches my program from inside the whyteboard source package.

So:

    whyteboard/
     ├── locale/
     ├── images
     ├── whyteboard-help/
     ├── whyteboard/
     │  ├── __init__.py
     │  └── other packages etc
     ├── whyteboard.py
     ├── README
     ├── setup.py
     └── CHANGELOG

This mirrors the source of my program, is how everything should be, and is correct.


However when I run &quot;python setup.py install&quot; none of my data files are written - only the &quot;whyteboard&quot; source package, and the whyteboard.py is placed in /usr/local/lib/python2.6/dist-packages/.

Ideally, I&#39;d like the same directory structure as what&#39;s been generated in the .tar.gz file to be created in dist-packages, as this is how my program expects to look for its resources. 

How can I get &quot;install&quot; to create this directory structure? It seems to be ignoring my manifest file, as far as I can tell.


MANIFEST.in ignored on &quot;python setup.py install&quot; - no data files installed?

I tried to install the Twilio module:

    sudo -H pip install twilio

And I got this error:

    Installing collected packages: pyOpenSSL
      Found existing installation: pyOpenSSL 0.13.1
    Cannot uninstall &#39;pyOpenSSL&#39;. It is a distutils installed project and             
    thus we cannot accurately determine which files belong to it which 
    would lead to only a partial uninstall.

Anyone know how to uninstall pyOpenSSL?

pip cannot uninstall &lt;package&gt;: &quot;It is a distutils installed project&quot;

There is a ton of information on how to do this, but since *&quot;there is more than one way to skin a cat&quot;*, and all the tutorials/manuals that cover a bit of the process seem to make certain assumptions which are different from other tutorials, I still didn&#39;t manage to grasp it.

So far this is what I think I understood.

1. My final goal should be that of creating a &quot;binary&quot; .deb package. Such package will be platform-independent (32/64 bit) as all Python programs are such.
2. To create a &quot;binary&quot; package I need first to create a source package.
3. To create the source package I can use either `CDBS` or `debhelper`. Debhelper is the recommended way for beginners.
4. The core of creating a source package is populating the `DEBIAN` directory in the source directory with a number of files clarifying where files need to be copied, what copyright and licensing scheme they are subject to, what dependencies they have, etc...
5. Step #4 can be largely automated the `dh_make`command *if* the Python source also comes with a distutils&#39; `setup.py` script.

Now my questions:

1. **Is my understanding of the process correct?** Is there anything I am missing, or anything that I got wrong?
2. Step #5 is really the more confusing to me: specifically the two points that remains most obscure to me are:
   - **How do I write a `setup.py` script that install a stand-alone programme?** **EDIT:** By _standalone programme_ I mean a program intended to be used by a desktop user (as opposed to a _module_ which I understand like a collection of functionality to be used by other software after having been imported). In my specific case I would actually need *two* such &quot;programs&quot;: the main software and a separate utility (in effect a second &quot;program&quot; that should be in the same package with the other one).
   - **What are the specificities of such a script for DEB packages?** The official documentation only seems to deal with RPM and Windows stuff...

BTW: These are the best sources of information that I could find myself so far. If you have anything better than this, please share! :)

- [Ubuntu&#39;s Python packaging guide][1]
- [Creating a .deb package from a python setup.py][2] (it _shows_ the steps, but it doesn&#39;t _explain_ them enough for me to follow along)
- [ShowMeDo video on &quot;creating a .deb package out of a python
  program&quot;][3] (it doesn&#39;t seem up-to-date and - if I got it right - will produce packages for personal use, without dependencies
and without a signed changelog and other key data that will make it incompatible with the Debian policy).

  [1]: https://wiki.ubuntu.com/PackagingGuide/Python#The_debhelper_way
  [2]: http://ghantoos.org/2008/10/19/creating-a-deb-package-from-a-python-setuppy/
  [3]: http://showmedo.com/videotutorials/series?name=linuxJensMakingDebSeries


Is there a standard way to create Debian packages for distributing Python programs?

I&#39;m trying to copy `/home/myUser/dir1/` and all its contents (and their contents, etc.) to `/home/myuser/dir2/` in python. Furthermore, I want the copy to overwrite everything in `dir2/`.

It *looks* like `distutils.dir_util.copy_tree` might be the right tool for the job, but not sure if there&#39;s anything easier/more obvious to use for such a simple task.

If it is the right tool, how do I use it? According to the [docs](http://docs.python.org/distutils/apiref.html) there are 8 parameters that it takes. Do I have to pass all 8 are just `src`, `dst` and `update`, and if so, how (I&#39;m brand new to Python).

If there&#39;s something out there that&#39;s better, can someone give me an example and point me in the right direction? Thanks in advance!

How to copy directory recursively in python and overwrite all?

I would like to use `tox` to run my unittests in two virtualenvs, since my application has to support 2 different Python versions.

My problem is that `tox` requires a `setup.py`, but I have none since my application is not a module and has its own installer. For now I don&#39;t want to go through the hassle of automating the install process as to work with `setup.py`, I just want to run my unittests without having to write a `setup.py`.

Is that possible? Or how can I write an &quot;empty&quot; setup.py that simply does nothing? Can you point me towards some documentation on the subject (the `distutils` documentation explains how to write a meaningful `setup.py`, not an empty one)?

How do I run tox in a project that has no setup.py?

I have dependency_links in my setup.py: 

    ...
    dependency_links = [&#39;http://github.com/robot-republic/python-s3/tarball/master.tar.gz#egg=python-s3&#39;],
    ...

But it doesn&#39;t work. However install_requires works fine.
Maybe there are another method to set up git repo as required for setup.py?

pip ignores dependency_links in setup.py

Please prompt me how to pass a user-defined parameter both from the command line and setup.cfg configuration file to distutils&#39; setup.py script. I want to write a setup.py script, which accepts my package specific parameters. For example:

    python setup.py install -foo myfoo


distutils: How to pass a user defined parameter to setup.py?

With `distutils`, `setuptools`, etc. a package version is specified in `setup.py`:

    # file: setup.py
    ...
    setup(
    name=&#39;foobar&#39;,
    version=&#39;1.0.0&#39;,
    # other attributes
    )

I would like to be able to access the same version number from within the package:

    &gt;&gt;&gt; import foobar
    &gt;&gt;&gt; foobar.__version__
    &#39;1.0.0&#39;


----------


I could add `__version__ = &#39;1.0.0&#39;` to my package&#39;s \__init__.py, but I would also like to include additional imports in my package to create a simplified interface to the package:

    # file: __init__.py
   
    from foobar import foo
    from foobar.bar import Bar

    __version__ = &#39;1.0.0&#39;


and


    # file: setup.py

    from foobar import __version__
    ...
    setup(
    name=&#39;foobar&#39;,
    version=__version__,
    # other attributes
    )

However, these additional imports can cause the installation of `foobar` to fail if they import other packages that are not yet installed. What is the correct way to share package version with setup.py and the package?

What is the correct way to share package version with setup.py and the package?

I configured MinGW and distutils so now I can compile extensions using this command:

    setup.py install

MinGW&#39;s gcc compiler will be used and package will be installed. For that I installed MinGW and [created distutils.cfg](https://docs.python.org/2/install/#location-and-names-of-config-files) file with following content:

    [build]
    compiler = mingw32

It&#39;s cool but now I&#39;d like to use all pip benefits. Is there a way to use the same MinGW&#39;s gcc compiler in pip? So that when I run this:

    pip install &lt;package name&gt;

pip will use MinGW&#39;s gcc compiler and compile C code if needed?

Currently I get this error: `Unable to find vcvarsall.bat`. Seems pip doesn&#39;t know that I have gcc compiler. How can I configure pip to use gcc compiler?

How to use MinGW&#39;s gcc compiler when installing Python package using Pip?

I understand that `setup.py` uses the same `CFLAGS` that were used to build Python. I have a single C extension of ours that is segfaulting. I need to build it **without** `-O2` because `-O2` is optimizing out some values and code so that the core files are not sufficient to pin down the problem.

I just need to modify `setup.py` so that `-O2` is not used.

I&#39;ve read `distutils` documentation, in particular `distutils.ccompiler` and `distutils.unixccompiler` and see how to add flags and libs and includes, but not how to modify the default GCC flags.

Specifically, this is for a legacy product on Python 2.5.1 with a bunch of backports (Fedora 8, yes, I know...). No, I cannot change the OS or Python version and I cannot, without great problems, recompile Python. I just need to build a one off of the C extension for one customer whose environment is the only one segfaulting.

How may I override the compiler (GCC) flags that setup.py uses by default?

How could I make my `setup.py` pre-delete and post-delete the build directory?

Cleaning build directory in setup.py

I want to wrap a test project containing C++ and OpenMP code with Cython, and build it with distutils via a `setup.py` file. The content of my file looks like this:

    from distutils.core import setup
    from distutils.extension import Extension
    from Cython.Build import cythonize
    from Cython.Distutils import build_ext
    
    
    modules = [Extension(&quot;Interface&quot;,
    					 [&quot;Interface.pyx&quot;, &quot;Parallel.cpp&quot;],
    					 language = &quot;c++&quot;,
    					 extra_compile_args=[&quot;-fopenmp&quot;],
    					 extra_link_args=[&quot;-fopenmp&quot;])]
    
    for e in modules:
    	e.cython_directives = {&quot;embedsignature&quot; : True}
    
    setup(name=&quot;Interface&quot;,
    	 cmdclass={&quot;build_ext&quot;: build_ext},
    	 ext_modules=modules)

The `-fopenmp` flag is used with gcc to compile and link against OpenMP. However, if I just invoke

    cls ~/workspace/CythonOpenMP/src $ python3 setup.py build

this flag is not recognized, because the compiler is clang:

    running build
    running build_ext
    skipping &#39;Interface.cpp&#39; Cython extension (up-to-date)
    building &#39;Interface&#39; extension
    cc -Wno-unused-result -fno-common -dynamic -DNDEBUG -g -O3 -Wall -Wstrict-prototypes -I/usr/local/include -I/usr/local/opt/sqlite/include -I/usr/local/Cellar/python3/3.3.0/Frameworks/Python.framework/Versions/3.3/include/python3.3m -c Interface.cpp -o build/temp.macosx-10.8-x86_64-3.3/Interface.o -fopenmp
    clang: warning: argument unused during compilation: &#39;-fopenmp&#39;
    cc -Wno-unused-result -fno-common -dynamic -DNDEBUG -g -O3 -Wall -Wstrict-prototypes -I/usr/local/include -I/usr/local/opt/sqlite/include -I/usr/local/Cellar/python3/3.3.0/Frameworks/Python.framework/Versions/3.3/include/python3.3m -c Parallel.cpp -o build/temp.macosx-10.8-x86_64-3.3/Parallel.o -fopenmp
    clang: warning: argument unused during compilation: &#39;-fopenmp&#39;
    Parallel.cpp:24:10: warning: unknown pragma ignored [-Wunknown-pragmas]
            #pragma omp parallel for
                    ^
    1 warning generated.
    c++ -bundle -undefined dynamic_lookup -L/usr/local/lib -L/usr/local/opt/sqlite/lib build/temp.macosx-10.8-x86_64-3.3/Interface.o build/temp.macosx-10.8-x86_64-3.3/Parallel.o -o build/lib.macosx-10.8-x86_64-3.3/Interface.so -fopenmp
    ld: library not found for -lgomp
    clang: error: linker command failed with exit code 1 (use -v to see invocation)
    error: command &#39;c++&#39; failed with exit status 1

 I&#39;ve unsucessfully tried to specify gcc:

    cls ~/workspace/CythonOpenMP/src $ python3 setup.py build --compiler=g++-4.7
    running build
    running build_ext
    error: don&#39;t know how to compile C/C++ code on platform &#39;posix&#39; with &#39;g++-4.7&#39; compiler


How can I tell distutils to use gcc?







How to tell distutils to use gcc?

I&#39;m working toward adopting Python as part of my team&#39;s development tool suite. With the other languages/tools we use, we develop many reusable functions and classes that are specific to the work we do. This standardizes the way we do things and saves a lot of wheel re-inventing.

I can&#39;t seem to find any examples of how this is usually handled with Python. Right now I have a development folder on a local drive, with multiple project folders below that, and an additional &quot;common&quot; folder containing packages and modules with re-usable classes and functions. These &quot;common&quot; modules are imported by modules within multiple projects.

    Development/
        Common/
            Package_a/
            Package_b/
        Project1/
            Package1_1/
            Package1_2/
        Project2/
            Package2_1/
            Package2_2/
            
In trying to learn how to distribute a Python application, it seems that there is an assumption that all referenced packages are below the top-level project folder, not collateral to it. The thought also occurred to me that perhaps the correct approach is to develop common/framework modules in a separate project, and once tested, deploy those to each developer&#39;s environment by installing to the site-packages folder. However, that also raises questions re distribution.

Can anyone shed light on this, or point me to a resource that discusses this issue?


What is the proper way to work with shared modules in Python development?

I am dealing with a legacy Dockerfile. Here is a _very simplified_ version of what I am dealing with:

    FROM ubuntu:14.04
    
    RUN apt-get -y update &amp;&amp; apt-get -y install \
        python-pip \
        python-numpy # ...and many other packages
    
    RUN pip install -U pip
    
    RUN pip install -r /tmp/requirements1.txt # includes e.g., numpy==1.13.0
    RUN pip install -r /tmp/requirements2.txt
    RUN pip install -r /tmp/requirements3.txt

First, several packages are installed using `apt`, and then several packages are installed using `pip`. `pip` version 10 has been released, and [part of the release](https://pip.pypa.io/en/stable/news/#deprecations-and-removals) is this new restriction:

&gt; Removed support for uninstalling projects which have been installed using distutils. distutils installed projects do not include metadata indicating what files belong to that install and thus it is impossible to actually uninstall them rather than just remove the metadata saying they&#39;ve been installed while leaving all of the actual files behind. 

This leads to the following problem in my setup. For example, first `apt` installs `python-numpy`. Later `pip` tries to install a newer version of `numpy` from e.g., `/tmp/requirements1.txt`, and tries to uninstall the older version, but because of the new restriction, it cannot remove this version:

    Installing collected packages: numpy
      Found existing installation: numpy 1.8.2
    Cannot uninstall &#39;numpy&#39;. It is a distutils installed project and thus we cannot accurately determine which files belong to it which would lead to only a partial uninstall.


Now I know at this point there are several solutions.

I could not install `python-numpy` through `apt`. However, this causes issues because `python-numpy` installs a few different packages as requirements, and I do not know if another part of the system relies on these packages. And in reality, there are several `apt` packages installed through the Dockerfile, and each one I remove seems to reveal another `Cannot uninstall X` error, and removes a number of other packages along with it, that our app may or may not rely on. 

I could also use the `--ignore-installed` option when I try to `pip` install things that have already been installed through `apt`, but then again I have the same problem of every `--ignore-installed` argument revealing yet another thing that needs to be ignored.

I could pin `pip` at an older version that does not have this restriction, but I don&#39;t want to be stuck using an outdated version of `pip` forever. 

I have been going around in circles trying to come up with a good solution that involves minimal changes to this legacy Dockerfile, and allows the app we deploy with that file to continue to function as it has been. Any suggestions as to how I can safely get around this problem of `pip` 10 not being able to install newer versions of `distutils` packages? Thank you!

# UPDATE:

I did not realize that `--ignore-installed` could be used without a package as an argument to ignore all installed packages. I am considering whether or not this might be a good option for me, and have asked about it [here][1].


  [1]: https://stackoverflow.com/q/49932926/3642398

pip 10 and apt: how to avoid &quot;Cannot uninstall X&quot; errors for distutils packages

I&#39;m using Python 2.6 and cx_Freeze 4.1.2 on a Windows system. I&#39;ve created the setup.py to build my executable and everything works fine.

When cx_Freeze runs, it moves everything to the `build` directory. I have some other files that I would like included in my `build` directory. How can I do this? Here&#39;s my structure:

    src\
        setup.py
        janitor.py
        README.txt
        CHNAGELOG.txt
        helpers\
            uncompress\
                unRAR.exe
                unzip.exe

Here&#39;s my snippet:

&gt;  setup
&gt;      
&gt;     ( name=&#39;Janitor&#39;,
&gt;       version=&#39;1.0&#39;,
&gt;       description=&#39;Janitor&#39;,
&gt;       author=&#39;John Doe&#39;,
&gt;       author_email=&#39;john.doe@gmail.com&#39;,
&gt;       url=&#39;http://www.this-page-intentionally-left-blank.org/&#39;,
&gt;       data_files = 
&gt;           [ (&#39;helpers\uncompress&#39;, [&#39;helpers\uncompress\unzip.exe&#39;]),
&gt;             (&#39;helpers\uncompress&#39;, [&#39;helpers\uncompress\unRAR.exe&#39;]),
&gt;             (&#39;&#39;, [&#39;README.txt&#39;])
&gt;           ],
&gt;       executables =
&gt;           [
&gt;           Executable\
&gt;               (
&gt;               &#39;janitor.py&#39;, #initScript
&gt;               )
&gt;           ]
&gt;     )


I can&#39;t seem to get this to work. Do I need a `MANIFEST.in` file?

How can I bundle other files when using cx_freeze?

Let&#39;s say you have a project called `proj` and in this project you have the following structure:

    proj/
      dists/
      doc/
      src/
        __init__.py
        xyz.py
        abc.py
      test/
      setup.py

As you can see all the content of your project is in the `src` subfolder. How to go about making a distutils distribution package out of the `src` folder?

My naive idea, following [the tutorial](http://docs.python.org/2/distutils/setupscript.html), would&#39;ve been to write the `setup.py` like this:

    #omitting basics
    setup(
       name=&#39;proj&#39;,
       packages=[&#39;src&#39;],
       package_dir={&#39;proj&#39;:&#39;src&#39;}
    )

But after installing the resulting package to my system, I still have to import `src.xyz` and not `proj.xyz`, which would&#39;ve been the goal and the expected result.     



setup.py: renaming src package to project name

When I run

      python setup.py sdist

it creates an sdist in my ./dist directory. This includes a &quot;PROJECT-egg.info&quot; file in the zip inside my &quot;dist&quot; folder, which I don&#39;t use, but it doesn&#39;t hurt me, so I just ignore it.

My question is why does it *also* create a &quot;PROJECT-egg.info&quot; folder in my project root directory? Can I make it stop creating this? If not, can I just delete it immediately after creating the sdist?

I&#39;m using the &#39;setup&#39; function imported from setuptools.
WindowsXP, Python2.7, Setuptools 0.6c11, Distribute 0.6.14.

My setup config looks like:

    {&#39;author&#39;: &#39;Jonathan Hartley&#39;,
     &#39;author_email&#39;: &#39;tartley@tartley.com&#39;,
     &#39;classifiers&#39;: [&#39;Development Status :: 1 - Planning&#39;,
                     &#39;Intended Audience :: Developers&#39;,
                     &#39;License :: OSI Approved :: BSD License&#39;,
                     &#39;Operating System :: Microsoft :: Windows&#39;,
                     &#39;Programming Language :: Python :: 2.7&#39;],
     &#39;console&#39;: [{&#39;script&#39;: &#39;demo.py&#39;}],
     &#39;data_files&#39;: [(&#39;Microsoft.VC90.CRT&#39;,
                     [&#39;..\\lib\\Microsoft.VC90.CRT\\Microsoft.VC90.CRT.manifest&#39;,
                      &#39;..\\lib\\Microsoft.VC90.CRT\\msvcr90.dll&#39;])],
     &#39;description&#39;: &#39;Utilities for games and OpenGL graphics, built around Pyglet.\n&#39;,
     &#39;keywords&#39;: &#39;&#39;,
     &#39;license&#39;: &#39;BSD&#39;,
     &#39;long_description&#39;: &quot;blah blah blah&quot;,
     &#39;name&#39;: &#39;pygpen&#39;,
     &#39;options&#39;: {&#39;py2exe&#39;: {&#39;ascii&#39;: True,
                            &#39;bundle_files&#39;: 1,
                            &#39;dist_dir&#39;: &#39;dist/pygpen-0.1-windows&#39;,
                            &#39;dll_excludes&#39;: [],
                            &#39;excludes&#39;: [&#39;_imaging_gif&#39;,
                                         &#39;_scproxy&#39;,
                                         &#39;clr&#39;,
                                         &#39;dummy.Process&#39;,
                                         &#39;email&#39;,
                                         &#39;email.base64mime&#39;,
                                         &#39;email.utils&#39;,
                                         &#39;email.Utils&#39;,
                                         &#39;ICCProfile&#39;,
                                         &#39;Image&#39;,
                                         &#39;IronPythonConsole&#39;,
                                         &#39;modes.editingmodes&#39;,
                                         &#39;startup&#39;,
                                         &#39;System&#39;,
                                         &#39;System.Windows.Forms.Clipboard&#39;,
                                         &#39;_hashlib&#39;,
                                         &#39;_imaging&#39;,
                                         &#39;_multiprocessing&#39;,
                                         &#39;_ssl&#39;,
                                         &#39;_socket&#39;,
                                         &#39;bz2&#39;,
                                         &#39;pyexpat&#39;,
                                         &#39;pyreadline&#39;,
                                         &#39;select&#39;,
                                         &#39;win32api&#39;,
                                         &#39;win32pipe&#39;,
                                         &#39;calendar&#39;,
                                         &#39;cookielib&#39;,
                                         &#39;difflib&#39;,
                                         &#39;doctest&#39;,
                                         &#39;locale&#39;,
                                         &#39;optparse&#39;,
                                         &#39;pdb&#39;,
                                         &#39;pickle&#39;,
                                         &#39;pyglet.window.xlib&#39;,
                                         &#39;pyglet.window.carbon&#39;,
                                         &#39;pyglet.window.carbon.constants&#39;,
                                         &#39;pyglet.window.carbon.types&#39;,
                                         &#39;subprocess&#39;,
                                         &#39;tarfile&#39;,
                                         &#39;threading&#39;,
                                         &#39;unittest&#39;,
                                         &#39;urllib&#39;,
                                         &#39;urllib2&#39;,
                                         &#39;win32con&#39;,
                                         &#39;zipfile&#39;],
                            &#39;optimize&#39;: 2}},
     &#39;packages&#39;: [&#39;pygpen&#39;],
     &#39;scripts&#39;: [&#39;demo.py&#39;],
     &#39;url&#39;: &#39;http://code.google.com/p/edpath/&#39;,
     &#39;version&#39;: &#39;0.1&#39;,
     &#39;zipfile&#39;: None}

Why does &quot;python setup.py sdist&quot; create unwanted &quot;PROJECT-egg.info&quot; in project root directory?

I have a Python project in which I am using many non-code files. Currently these are all images, but I might use other kinds of files in the future. What would be a good scheme for storing and referencing these files?

I considered just making a folder &quot;resources&quot; in the main directory, but there is a problem; Some images are used from within sub-packages of my project. Storing these images that way would lead to coupling, which is a disadvantage.

Also, I need a way to access these files which is independent on what my current directory is.


Managing resources in a Python project

**SITUATION:**

I have a python library, which is controlled by git, and bundled with distutils/setuptools. And I want to automatically generate version number based on git tags, both for `setup.py sdist` and alike commands, and for the library itself.

For the first task I can use `git describe` or alike solutions (see  https://stackoverflow.com/questions/2058802/how-can-i-get-the-version-defined-in-setup-py-setuptools-in-my-package).

And when, for example, I am in a tag &#39;0.1&#39; and call for &#39;setup.py sdist&#39;, I get &#39;mylib-0.1.tar.gz&#39;; or &#39;mylib-0.1-3-abcd.tar.gz&#39; if I altered the code after tagging. This is fine.

**THE PROBLEM IS:**

The problem comes when I want to have this version number available for the library itself, so it could send it in User-Agent HTTP header as &#39;mylib/0.1-3-adcd&#39;.

If I add `setup.py version` command as in https://stackoverflow.com/questions/2058802/how-can-i-get-the-version-defined-in-setup-py-setuptools-in-my-package, then this version.py is generated AFTER the tag is made, since it uses the tag as a value. But in this case I need to make one more commit after the version tag is made to make the code consistent. Which, in turns, requires a new tag for further bundling.

**THE QUESTION IS:**

How to break this circle of dependencies (generate-commit-tag-generate-commit-tag-...)?


Automatic version number both in setup.py (setuptools) AND source code?

I have a new library that has to include a lot of subfolders of small datafiles, and I&#39;m trying to add them as package data.  Imagine I have my library as so:

     library
        - foo.py
        - bar.py
     data
       subfolderA
          subfolderA1
          subfolderA2
       subfolderB
          subfolderB1 
          ...

I want to add all of the data in all of the subfolders through setup.py, but it seems like I manually have to go into every single subfolder (there are 100 or so) and add an __init__.py file.  Furthermore, will setup.py find these files recursively, or do I need to manually add all of these in setup.py like:

    package_data={
      &#39;mypackage.data.folderA&#39;: [&#39;*&#39;],
      &#39;mypackage.data.folderA.subfolderA1&#39;: [&#39;*&#39;],
      &#39;mypackage.data.folderA.subfolderA2&#39;: [&#39;*&#39;]
       },

I can do this with a script, but seems like a super pain.  How can I achieve this in setup.py?

PS, the hierarchy of these folders is important because this is a database of material files and we want the file tree to be preserved when we present them in a GUI to the user, so it would be to our advantage to keep this file structure intact.

How to add package data recursively in Python setup.py?

I have a module that works both on python 2 and python 3. In Python&lt;3.2 I would like to install a specific package as a dependency. For Python&gt;=3.2.

Something like:

     install_requires=[
        &quot;threadpool &gt;= 1.2.7 if python_version &lt; 3.2.0&quot;,
     ],

How can one make that?

All Distutils Solutions on Gang of Coders

Total of 31 Distutils Solutions