#!/usr/bin/env python

#-*- coding: us-ascii -*-

'''

setup.py

Installation script for Python-LLFUSE.

Copyright (c) 2010 Nikolaus Rath <Nikolaus.org>

This file is part of Python-LLFUSE. This work may be distributed under

the terms of the GNU LGPL.

'''

from __future__ import division, print_function, absolute_import

import sys

import os

import subprocess

import warnings

import re

# Disable Cython support in setuptools. It fails under some conditions

# (http://trac.cython.org/ticket/859), and we have our own build_cython command

# anyway.

try:

import Cython.Distutils.build_ext

except ImportError:

pass

else:

# We can't delete Cython.Distutils.build_ext directly,

# because the build_ext class (that is imported from

# the build_ext module in __init__.py) shadows the

# build_ext module.

module = sys.modules['Cython.Distutils.build_ext']

del module.build_ext

try:

import setuptools

except ImportError:

raise SystemExit('Setuptools package not found. Please install from '

'https://pypi.python.org/pypi/setuptools')

from setuptools import Extension

from distutils.version import LooseVersion

# Add util to load path

basedir = os.path.abspath(os.path.dirname(sys.argv[0]))

sys.path.insert(0, os.path.join(basedir, 'util'))

# When running from HG repo, enable all warnings

DEVELOPER_MODE = os.path.exists(os.path.join(basedir, 'MANIFEST.in'))

if DEVELOPER_MODE:

print('found MANIFEST.in, running in developer mode')

warnings.resetwarnings()

# We can't use `error`, because e.g. Sphinx triggers a

# DeprecationWarning.

warnings.simplefilter('default')

# Add src to load path, important for Sphinx autodoc

# to work properly

sys.path.insert(0, os.path.join(basedir, 'src'))

LLFUSE_VERSION = '1.3.5'

def main():

try:

from sphinx.application import Sphinx #pylint: disable-msg=W0612

except ImportError:

pass

else:

fix_docutils()

with open(os.path.join(basedir, 'README.rst'), 'r') as fh:

long_desc = fh.read()

compile_args = pkg_config('fuse', cflags=True, ldflags=False, min_ver='2.8.0')

compile_args += ['-DFUSE_USE_VERSION=29', '-Wall', '-Wextra', '-Wconversion',

'-Wsign-compare', '-DLLFUSE_VERSION="%s"' % LLFUSE_VERSION]

# We may have unused functions if we compile for older FUSE versions

compile_args.append('-Wno-unused-function')

# Nothing wrong with that if you know what you are doing

# (which Cython does)

compile_args.append('-Wno-implicit-fallthrough')

# Due to platform specific conditions, these are unavoidable

compile_args.append('-Wno-unused-parameter')

# Enable all fatal warnings only when compiling from Mercurial tip.

# (otherwise we break forward compatibility because compilation with newer

# compiler may fail if additional warnings are added)

if DEVELOPER_MODE:

compile_args.append('-Werror')

compile_args.append('-Wfatal-errors')

# Unreachable code is expected because we need to support multiple

# platforms and architectures.

compile_args.append('-Wno-error=unreachable-code')

# Value-changing conversions should always be explicit.

compile_args.append('-Werror=conversion')

# Note that (i > -1) is false if i is unsigned (-1 will be converted to

# a large positive value). We certainly don't want to do this by

# accident.

compile_args.append('-Werror=sign-compare')

# http://bugs.python.org/issue7576

if sys.version_info[0] == 3 and sys.version_info[1] < 2:

compile_args.append('-Wno-error=missing-field-initializers')

# http://bugs.python.org/issue969718

if sys.version_info[0] == 2:

compile_args.append('-fno-strict-aliasing')

link_args = pkg_config('fuse', cflags=False, ldflags=True, min_ver='2.8.0')

link_args.append('-lpthread')

c_sources = ['src/llfuse.c', 'src/lock.c']

if os.uname()[0] in ('Linux', 'GNU/kFreeBSD'):

link_args.append('-lrt')

elif os.uname()[0] == 'Darwin':

c_sources.append('src/darwin_compat.c')

install_requires = []

if sys.version_info[0] == 2:

install_requires.append('contextlib2')

setuptools.setup(

name='llfuse',

zip_safe=True,

version=LLFUSE_VERSION,

description='Python bindings for the low-level FUSE API',

long_description=long_desc,

author='Nikolaus Rath',

author_email='[email protected]',

url='https://bitbucket.org/nikratio/python-llfuse/',

download_url='https://bitbucket.org/nikratio/python-llfuse/downloads',

license='LGPL',

classifiers=['Development Status :: 4 - Beta',

'Intended Audience :: Developers',

'Programming Language :: Python',

'Topic :: Software Development :: Libraries :: Python Modules',

'Topic :: System :: Filesystems',

'License :: OSI Approved :: GNU Library or Lesser General Public License (LGPL)',

'Operating System :: POSIX :: Linux',

'Operating System :: MacOS :: MacOS X',

'Operating System :: POSIX :: BSD :: FreeBSD'],

platforms=[ 'Linux', 'FreeBSD', 'OS X' ],

keywords=['FUSE', 'python' ],

package_dir={'': 'src'},

packages=setuptools.find_packages('src'),

provides=['llfuse'],

ext_modules=[Extension('llfuse', c_sources,

extra_compile_args=compile_args,

extra_link_args=link_args)],

cmdclass={'upload_docs': upload_docs,

'build_cython': build_cython },

command_options={

'build_sphinx': {

'version': ('setup.py', LLFUSE_VERSION),

'release': ('setup.py', LLFUSE_VERSION),

}},

install_requires=install_requires,

)

def pkg_config(pkg, cflags=True, ldflags=False, min_ver=None):

'''Frontend to ``pkg-config``'''

if min_ver:

cmd = ['pkg-config', pkg, '--atleast-version', min_ver ]

if subprocess.call(cmd) != 0:

cmd = ['pkg-config', '--modversion', pkg ]

proc = subprocess.Popen(cmd, stdout=subprocess.PIPE)

version = proc.communicate()[0].strip()

if not version:

raise SystemExit() # pkg-config generates error message already

else:

raise SystemExit('%s version too old (found: %s, required: %s)'

% (pkg, version, min_ver))

cmd = ['pkg-config', pkg ]

if cflags:

cmd.append('--cflags')

if ldflags:

cmd.append('--libs')

proc = subprocess.Popen(cmd, stdout=subprocess.PIPE)

cflags = proc.stdout.readline().rstrip()

proc.stdout.close()

if proc.wait() != 0:

raise SystemExit() # pkg-config generates error message already

return cflags.decode('us-ascii').split()

class upload_docs(setuptools.Command):

user_options = []

boolean_options = []

description = "Upload documentation"

def initialize_options(self):

pass

def finalize_options(self):

pass

def run(self):

subprocess.check_call(['rsync', '-aHv', '--del', os.path.join(basedir, 'doc', 'html') + '/',

'ebox.rath.org:/srv/www.rath.org/llfuse-docs/'])

class build_cython(setuptools.Command):

user_options = []

boolean_options = []

description = "Compile .pyx to .c"

def initialize_options(self):

pass

def finalize_options(self):

self.extensions = self.distribution.ext_modules

def run(self):

try:

version = subprocess.check_output(['cython', '--version'],

universal_newlines=True,

stderr=subprocess.STDOUT)

except OSError:

raise SystemExit('Cython needs to be installed for this command')

hit = re.match('^Cython version (.+)$', version)

if not hit or LooseVersion(hit.group(1)) < "0.24":

raise SystemExit('Need Cython 0.24 or newer, found ' + version)

cmd = ['cython', '-Wextra', '--force', '-3', '--fast-fail',

'--directive', 'embedsignature=True', '--include-dir',

os.path.join(basedir, 'Include'), '--verbose' ]

if DEVELOPER_MODE:

cmd.append('-Werror')

# Work around http://trac.cython.org/cython_trac/ticket/714

cmd += ['-X', 'warn.maybe_uninitialized=False' ]

for extension in self.extensions:

for file_ in extension.sources:

(file_, ext) = os.path.splitext(file_)

path = os.path.join(basedir, file_)

if ext != '.c':

continue

if os.path.exists(path + '.pyx'):

if subprocess.call(cmd + [path + '.pyx']) != 0:

raise SystemExit('Cython compilation failed')

def fix_docutils():

'''Work around https://bitbucket.org/birkenfeld/sphinx/issue/1154/'''

import docutils.parsers

from docutils.parsers import rst

old_getclass = docutils.parsers.get_parser_class

# Check if bug is there

try:

old_getclass('rst')

except AttributeError:

pass

else:

return

def get_parser_class(parser_name):

"""Return the Parser class from the `parser_name` module."""

if parser_name in ('rst', 'restructuredtext'):

return rst.Parser

else:

return old_getclass(parser_name)

docutils.parsers.get_parser_class = get_parser_class

assert docutils.parsers.get_parser_class('rst') is rst.Parser

if __name__ == '__main__':

main()