Pfadangabe liefert Fehlermeldung (setup, ext_package )

[hypnoticum]

Hallo,
ich bekomme folgende Fehlermeldung:

"warning: install_lib: 'build\lib.win32-2.6' does not exist -- no Python modules to install"

wenn ich "setup()" mit "ext_package = os.getcwd()" aufrufe.
Lasse ich zunächst die Pfadangabe bzw. das "ext_package"-Argument aus funktioniert es direkt danach auch mit.
Wenn ich aber anschließend den "build"-Ordner lösche ist die Fehlermeldung wieder da.
Der "build"-Ordner enthält auch den Pfad zu der "lib.win32-2.6"-Datei. Nur wird er im einen Fall erzeugt und im anderen nicht.

Hat jemand eine Idee?

[Leonidas]

Hat jemand eine Idee?

Nicht ``os.getcwd()`` nutzen, um reproduzierbare Builds zu bekommen, unabhängig von dem Ordner aus dem der User das Skript aufruft?

[hypnoticum]

@Leonidas:
reproduzierbare Builds? wie meinst du das? "os.getcwd()" ist ja gerade der Sinn der Sache.

[Leonidas]

``os.getcwd()`` ändert sich ja immer, je nachdem in welchem Ordner der User ist. Wenn dein Paket in ``~/python/deinpaket-1.0`` ist und der User in ``~`` ist, und dein Paket via ``python python/deinpaket-1.0/setup.py install`` installieren will, was dann?

[hypnoticum]

Ok, bisher starte ich die Skripte immer direkt. Ich will einfach nur erreichen, daß die Extension im im gleichen Verzeichnis bzw. relativ zu dem Verzeichnis erzeugt wird in dem das setup-script liegt.
Wenn ich vorher

Code: Alles auswählen

if not os.path.isdir('build/lib.win32-2.6'):
    try:
        os.mkdir('build')
        os.mkdir('build/lib.win32-2.6')
    except:
        print 'cant make directory \"build/lib.win32-2.6\"'

einfüge klappt es (dämlicherweise)

[Leonidas]

Warum erstellst du die denn überhaupt selbst? Das macht doch distutils.

[hypnoticum]

@Leonidas:
"die" Verzeichnisse, oder was meinst du?

Der "build"-Ordner enthält auch den Pfad zu der "lib.win32-2.6"-Datei. Nur wird er im einen Fall erzeugt und im anderen nicht.

[Leonidas]

Zeig doch einfach mal deine ``setup.py``.

[hypnoticum]

"meine setup.py" - gibt es die? Ich dachte ich importiere das Script einfach nur ...

Code: Alles auswählen

import sys
import os
from distutils.core import setup, Extension

sys.argv.append('install') 

modul = Extension('Ext', 
                  sources = ['C/Module.c'],
                  depends = ['Common.h', 
                             'Test.c'],
                  include_dirs = ['H:/Python/Projects/Py_Workspace/PyAT/src/Device/C',
                                  'C:/Program Files/IVI Foundation/VISA/WinNT/include',
                                  'C:/Python26/include'],
                  library_dirs = ['C:/Program Files/IVI Foundation\VISA/WinNT/lib/msc'],
                  libraries = ['visa32'])  

if not os.path.isdir('build/lib.win32-2.6'):
    try:
        os.mkdir('build')
        os.mkdir('build/lib.win32-2.6')
    except:
        print 'cant make directory \"build/lib.win32-2.6\"'

setup( 
     name = "Module", 
     version = "1.0", 
     description = "C-Extensions Module", 
     ext_package = os.getcwd(),
     ext_modules = [modul] 
     )

und so steht es dann in der disutils.core.py:

Code: Alles auswählen

def setup (**attrs):
    """The gateway to the Distutils: do everything your setup script needs
    to do, in a highly flexible and user-driven way.  Briefly: create a
    Distribution instance; find and parse config files; parse the command
    line; run each Distutils command found there, customized by the options
    supplied to 'setup()' (as keyword arguments), in config files, and on
    the command line.

    The Distribution instance might be an instance of a class supplied via
    the 'distclass' keyword argument to 'setup'; if no such class is
    supplied, then the Distribution class (in dist.py) is instantiated.
    All other arguments to 'setup' (except for 'cmdclass') are used to set
    attributes of the Distribution instance.

    The 'cmdclass' argument, if supplied, is a dictionary mapping command
    names to command classes.  Each command encountered on the command line
    will be turned into a command class, which is in turn instantiated; any
    class found in 'cmdclass' is used in place of the default, which is
    (for command 'foo_bar') class 'foo_bar' in module
    'distutils.command.foo_bar'.  The command class must provide a
    'user_options' attribute which is a list of option specifiers for
    'distutils.fancy_getopt'.  Any command-line options between the current
    and the next command are used to set attributes of the current command
    object.

    When the entire command-line has been successfully parsed, calls the
    'run()' method on each command object in turn.  This method will be
    driven entirely by the Distribution object (which each command object
    has a reference to, thanks to its constructor), and the
    command-specific options that became attributes of each command
    object.
    """

    global _setup_stop_after, _setup_distribution

    # Determine the distribution class -- either caller-supplied or
    # our Distribution (see below).
    klass = attrs.get('distclass')
    if klass:
        del attrs['distclass']
    else:
        klass = Distribution

    if 'script_name' not in attrs:
        attrs['script_name'] = os.path.basename(sys.argv[0])
    if 'script_args' not in attrs:
        attrs['script_args'] = sys.argv[1:]

    # Create the Distribution instance, using the remaining arguments
    # (ie. everything except distclass) to initialize it
    try:
        _setup_distribution = dist = klass(attrs)
    except DistutilsSetupError, msg:
        if 'name' in attrs:
            raise SystemExit, "error in %s setup command: %s" % \
                  (attrs['name'], msg)
        else:
            raise SystemExit, "error in setup command: %s" % msg

    if _setup_stop_after == "init":
        return dist

    # Find and parse the config file(s): they will override options from
    # the setup script, but be overridden by the command line.
    dist.parse_config_files()

    if DEBUG:
        print "options (after parsing config files):"
        dist.dump_option_dicts()

    if _setup_stop_after == "config":
        return dist

    # Parse the command line; any command-line errors are the end user's
    # fault, so turn them into SystemExit to suppress tracebacks.
    try:
        ok = dist.parse_command_line()
    except DistutilsArgError, msg:
        raise SystemExit, gen_usage(dist.script_name) + "\nerror: %s" % msg

    if DEBUG:
        print "options (after parsing command line):"
        dist.dump_option_dicts()

    if _setup_stop_after == "commandline":
        return dist

    # And finally, run all the commands found on the command line.
    if ok:
        try:
            dist.run_commands()
        except KeyboardInterrupt:
            raise SystemExit, "interrupted"
        except (IOError, os.error), exc:
            error = grok_environment_error(exc)

            if DEBUG:
                sys.stderr.write(error + "\n")
                raise
            else:
                raise SystemExit, error

        except (DistutilsError,
                CCompilerError), msg:
            if DEBUG:
                raise
            else:
                raise SystemExit, "error: " + str(msg)

    return dist