[segyio] 01/01: New upstream version 1.3.6
Jørgen Kvalsvik
jokva-guest at moszumanska.debian.org
Tue Nov 21 13:29:11 UTC 2017
This is an automated email from the git hooks/post-receive script.
jokva-guest pushed a commit to annotated tag upstream/1.3.6
in repository segyio.
commit 2820f639e42671cc2ab93a370e8541f4a20c91ad
Author: Jørgen Kvalsvik <jokva at statoil.com>
Date: Tue Nov 21 11:15:47 2017 +0100
New upstream version 1.3.6
---
.gitmodules | 3 -
.pyup.yml | 4 +
.travis.yml | 34 +-
CMakeLists.txt | 126 ++++-
README.md | 15 +-
applications/CMakeLists.txt | 77 ++-
applications/segyio-catb.c | 4 +-
applications/segyio-crop.c | 30 +-
applications/test/catb.py | 30 --
applications/test/cath.py | 18 -
applications/test/catr.py | 32 +-
appveyor.yml | 25 +-
changelog.md | 31 +-
cmake/check_includes.cmake | 40 --
cmake/default_warnings.cmake | 9 -
cmake/segyio_testing.cmake | 32 --
config.sh | 25 +-
lib/CMakeLists.txt | 28 +-
lib/src/segy.c | 14 +-
lib/test/segy.c | 3 +-
mex/CMakeLists.txt | 2 +-
{cmake => mex}/matlab.cmake | 0
pycmake/.travis.yml | 21 -
pycmake/CMakeLists.txt | 10 -
pycmake/FindPythonModule.cmake | 168 -------
pycmake/LICENSE | 674 --------------------------
pycmake/PythonPackage.cmake | 817 --------------------------------
pycmake/README.md | 132 ------
pycmake/test/CMakeLists.txt | 31 --
python/CMakeLists.txt | 162 ++++---
python/examples/write.py | 2 +-
python/segyio/__init__.py | 6 +-
python/segyio/_gather.py | 41 +-
python/segyio/{_segyio.c => segyio.cpp} | 52 +-
python/segyio/version.py | 1 +
python/setup.py.in | 78 ---
python/test/__init__.py | 0
python/test/context.py | 11 +-
python/test/segy.py | 11 +-
python/test/segyio_c.py | 10 +-
python/test/tools.py | 10 +-
requirements.txt | 1 +
requires.txt | 1 -
setup.py | 75 ++-
44 files changed, 551 insertions(+), 2345 deletions(-)
diff --git a/.gitmodules b/.gitmodules
index 392e368..347fe93 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,6 +1,3 @@
-[submodule "pycmake"]
- path = pycmake
- url = https://github.com/statoil/pycmake
[submodule "multibuild"]
path = multibuild
url = https://github.com/matthew-brett/multibuild.git
diff --git a/.pyup.yml b/.pyup.yml
new file mode 100644
index 0000000..604f69f
--- /dev/null
+++ b/.pyup.yml
@@ -0,0 +1,4 @@
+# autogenerated pyup.io config file
+# see https://pyup.io/docs/configuration/ for all available options
+
+update: insecure
diff --git a/.travis.yml b/.travis.yml
index 22257cc..847e839 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -58,29 +58,23 @@ before_install:
- before_install
install:
- # on os x, python is set up in a virtualenv, but cmake tends to find a
- # system-installed, incompatible python lib.
- if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then
brew update && brew install cppcheck;
- if [[ -n "${MB_PYTHON_VERSION+1}" ]]; then
- prefix=`python-config --prefix`;
- pypath=$prefix/lib/libpython$MB_PYTHON_VERSION.dylib;
- pylib="-DPYTHON_LIBRARY=$pypath";
- fi
fi
- - pip install numpy --upgrade
+ - pip install -r requirements.txt
before_script:
- enabled="-DBUILD_PYTHON=OFF -DBUILD_MEX=OFF"
- if [[ -n "${MB_PYTHON_VERSION+1}" ]]; then
- enabled="$enabled -DBUILD_PYTHON=ON";
+ enabled="$enabled -DBUILD_PYTHON=ON -DREQUIRE_PYTHON=ON";
fi
- cmake --version
- mkdir build
- pushd build
- cmake -DCMAKE_EXPORT_COMPILE_COMMANDS=ON
-DBUILD_SHARED_LIBS=ON
- $pylib $enabled ..
+ -DCMAKE_BUILD_TYPE=Release
+ $enabled ..
- cppcheck --language=c
--std=c99
--enable=style,portability,performance,warning
@@ -92,30 +86,28 @@ before_script:
--error-exitcode=1
- popd
+# distutils/setuptools on macos ignores the --rpath argument, so set
+# DYLD_LIBRARY_PATH so that the freshly-built image is picked up on for the
+# tests
script:
- pushd build
+ - export DYLD_LIBRARY_PATH=$PWD/lib
- make && ctest --output-on-failure
- - cat python/setup.py
+ - sudo make install
- popd
- - BUILD_COMMANDS=build_bdist_wheel build_wheel build/python
+ - build_wheel . $PLAT
- install_run $PLAT
- - mv wheelhouse build/python/dist
+ - mv wheelhouse dist
before_deploy:
# OS X ships with a tar that doesn't support --exclude-vcs, which is
# unproblematic as long as source code is uploaded from linux.
- if [[ "$TRAVIS_OS_NAME" == "linux" && ! -d segyio-$VERSION ]]; then
git clone $TRAVIS_BUILD_DIR segyio-$VERSION;
- pushd segyio-$VERSION;
- git submodule update --init pycmake;
- popd;
+ echo "version = '$TRAVIS_TAG'" > segyio-$VERSION/python/segyio/version.py;
tar --exclude-vcs -C $TRAVIS_BUILD_DIR -czvf segyio-$VERSION.tar.gz segyio-$VERSION;
zip --exclude *.git -r segyio-$VERSION.zip $TRAVIS_BUILD_DIR/segyio-$VERSION/*;
fi
- - pushd build/python
-
-after_deploy:
- - popd
deploy:
- provider: pypi # source distribution (done from linux python 3.6 only)
@@ -138,7 +130,7 @@ deploy:
on:
tags: true
- - provider: releases # upload tarball with submodule
+ - provider: releases # upload tarball and zip with source code
skip_cleanup: true
overwrite: true
file:
diff --git a/CMakeLists.txt b/CMakeLists.txt
index cbb1c70..bfadb65 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,35 +1,123 @@
-cmake_minimum_required(VERSION 2.8.11)
+cmake_minimum_required(VERSION 2.8.12)
project(segyio)
+include(CheckFunctionExists)
+include(CheckIncludeFile)
+include(CTest)
include(GNUInstallDirs)
-set(segyio_MAJOR 1 CACHE STRING "")
-set(segyio_MINOR 3 CACHE STRING "")
-set(segyio_PATCH 3 CACHE STRING "")
+if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/.git)
+ find_program(git-bin git)
+ execute_process(COMMAND ${git-bin} describe --tags
+ OUTPUT_VARIABLE git-describe
+ OUTPUT_STRIP_TRAILING_WHITESPACE
+ RESULT_VARIABLE describe-failure
+ WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+ )
+ if (NOT describe-failure)
+ message(STATUS "Found version ${git-describe} from git")
+ else ()
+ message(STATUS "No version from git - falling back to 0.0.0")
+ set(git-describe 0.0.0)
+ endif ()
+
+ string(REGEX REPLACE "^v" "" ver-describe "${git-describe}")
+ unset(git-bin)
+elseif (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/python/segyio/version.py)
+ # tarball checkout - the version file should've been written when the
+ # tarball was built
+ file(READ python/segyio/version.py ver-describe)
+ string(REGEX REPLACE "^version =" "" ver-describe ${ver-describe})
+ string(REGEX REPLACE "'" "" ver-describe ${ver-describe})
+ string(STRIP ${ver-describe} ver-describe)
+ message(STATUS "Found version ${ver-describe} from segyio/version.py")
+else ()
+ set(ver-describe 0.0.0)
+ message(STATUS "Could not find version, guessing ${ver-describe}")
+endif ()
+
+string(REPLACE . ";" version-list ${ver-describe})
+list(GET version-list 0 segyio-major)
+list(GET version-list 1 segyio-minor)
+list(GET version-list 2 segyio-patch)
+unset(version-list)
+
+# versions can always be overriden with -Dsegyio_MAJOR=N
+set(segyio_MAJOR ${segyio-major} CACHE STRING "Major version")
+set(segyio_MINOR ${segyio-minor} CACHE STRING "Minor version")
+set(segyio_PATCH ${segyio-patch} CACHE STRING "Patch")
set(segyio_VERSION ${segyio_MAJOR}.${segyio_MINOR}.${segyio_PATCH})
+message(STATUS "segyio version ${segyio_VERSION}")
if (POLICY CMP0042)
cmake_policy(SET CMP0042 NEW)
endif ()
-option(BUILD_SHARED_LIBS "Build language bindings shared" OFF)
-option(BUILD_PYTHON "Build Python wrappers" ON)
-option(BUILD_MEX "Build Matlab mex files" OFF)
+option(BUILD_SHARED_LIBS "Build language bindings shared" OFF)
+option(BUILD_PYTHON "Build Python library" ON)
+option(REQUIRE_PYTHON "Fail cmake if python cannot be built" OFF)
+option(BUILD_MEX "Build Matlab mex files" OFF)
+
+check_include_file(netinet/in.h HAVE_NETINET_IN_H)
+check_include_file(arpa/inet.h HAVE_ARPA_INET_H)
+check_include_file(winsock2.h HAVE_WINSOCK2_H)
+check_include_file(getopt.h HAVE_GETOPT_H)
+check_include_file(sys/mman.h HAVE_SYS_MMAN_H)
+check_include_file(sys/stat.h HAVE_SYS_STAT_H)
+check_function_exists(getopt_long HAVE_GETOPT_LONG)
+
+if (HAVE_NETINET_IN_H)
+ list(APPEND htons -DHAVE_NETINET_IN_H)
+elseif (HAVE_ARPA_INET_H)
+ list(APPEND htons -DHAVE_ARPA_INET_H)
+elseif (HAVE_WINSOCK2_H)
+ set(ws2 ws2_32)
+ list(APPEND htons -DHAVE_WINSOCK2_H)
+else()
+ message(FATAL_ERROR "Could not find htons")
+endif()
-if (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
- set(MAC_OS TRUE)
-elseif (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
- set(LINUX TRUE)
-elseif (${CMAKE_SYSTEM_NAME} MATCHES "Windows")
- set(WINDOWS TRUE)
+if (HAVE_SYS_MMAN_H)
+ list(APPEND mmap -DHAVE_MMAP)
+endif()
+
+if (HAVE_SYS_STAT_H)
+ list(APPEND fstat -DHAVE_SYS_STAT_H)
+
+ check_function_exists(_fstati64 HAVE_FSTATI64)
+ if (HAVE_FSTATI64)
+ list(APPEND fstat -DHAVE_FSTATI64)
+ endif ()
+
+ check_function_exists(_ftelli64 HAVE_FTELLI64)
+ if (HAVE_FTELLI64)
+ list(APPEND fstat -DHAVE_FTELLI64)
+ endif ()
+else()
+ message(FATAL_ERROR "Could not find sys/stat.h (fstat/ftelli)")
+endif()
+
+check_function_exists(ftello HAVE_FTELLO)
+if (HAVE_FTELLO)
+ list(APPEND ftello -DHAVE_FTELLO)
endif ()
-list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/pycmake)
-list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
-include(check_includes)
-include(default_warnings)
-include(segyio_testing)
-enable_testing()
+if(NOT MSVC)
+ set(m m)
+endif()
+
+if (NOT MSVC)
+ # assuming gcc-style options
+ set(c99 -std=c99)
+ # add warnings in debug mode
+ list(APPEND warnings-c -Wall -Wextra -pedantic -Wformat-nonliteral
+ -Wcast-align -Wpointer-arith -Wmissing-declarations
+ -Wcast-qual -Wwrite-strings -Wchar-subscripts
+ -Wredundant-decls
+ )
+else()
+ list(APPEND warnings-c /W3 /wd4996)
+endif ()
set(testdata ${CMAKE_CURRENT_SOURCE_DIR}/test-data)
diff --git a/README.md b/README.md
index 0f65db9..880d464 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,9 @@
-# SEGY IO [](https://travis-ci.org/Statoil/segyio)
+# SEGY IO
+
+[](https://travis-ci.org/Statoil/segyio)
+[](https://ci.appveyor.com/project/statoil-travis/segyio)
+[](https://pyup.io/repos/github/Statoil/segyio/)
+[](https://pyup.io/repos/github/Statoil/segyio/)
## Introduction ##
@@ -50,6 +55,7 @@ python interpreter and type `help(segyio)` to get started.
To build and use segyio you need:
* A C99 compatible C compiler (tested mostly on gcc and clang)
+ * A C++ compiler for the python extension
* [CMake](https://cmake.org/) version 2.8.8 or greater
* [Python](https://www.python.org/) 2.7 or 3.x.
@@ -60,7 +66,7 @@ To build and use segyio you need:
To build and install segyio, perform the following actions in your console:
```
-git clone --recursive https://github.com/Statoil/segyio
+git clone https://github.com/Statoil/segyio
cd segyio
mkdir build
cd build
@@ -74,11 +80,6 @@ in your home directory, add `-DCMAKE_INSTALL_PREFIX=~/` or some other
appropriate directory. Remember to update your $PATH! By default, only the
python bindings are built.
-Passing recursive to `git clone` also fetches statoil/pycmake and
-matthew-brett/multibuild. The former is cmake features for managing python
-packages, and the latter tools for building OS X and linux binary packages for
-pip.
-
##### Matlab support #####
To build the matlab bindings, invoke CMake with the option `-DBUILD_MEX=ON`. In
diff --git a/applications/CMakeLists.txt b/applications/CMakeLists.txt
index 9842f8d..504ac69 100644
--- a/applications/CMakeLists.txt
+++ b/applications/CMakeLists.txt
@@ -5,12 +5,11 @@ if( NOT HAVE_GETOPT_H OR NOT HAVE_GETOPT_LONG )
return ()
endif ()
-if (NOT MSVC)
- set(CMAKE_C_FLAGS "-std=c99 ${CMAKE_C_FLAGS}")
-endif()
-
add_library(apputils STATIC apputils.c)
target_link_libraries(apputils segyio)
+target_compile_options(apputils BEFORE
+ PRIVATE $<$<CONFIG:Debug>:${warnings-c}> ${c99}
+)
target_compile_definitions(apputils PUBLIC
-Dsegyio_MAJOR=${segyio_MAJOR}
-Dsegyio_MINOR=${segyio_MINOR}
@@ -18,31 +17,83 @@ target_compile_definitions(apputils PUBLIC
add_executable(segyinfo segyinfo.c)
target_link_libraries(segyinfo segyio)
+target_compile_options(segyinfo BEFORE
+ PRIVATE $<$<CONFIG:Debug>:${warnings-c}> ${c99}
+)
add_executable(segyinspect segyinspect.c)
target_link_libraries(segyinspect segyio)
+target_compile_options(segyinspect BEFORE
+ PRIVATE $<$<CONFIG:Debug>:${warnings-c}> ${c99}
+)
add_executable(segyio-cath segyio-cath.c)
target_link_libraries(segyio-cath segyio apputils)
+target_compile_options(segyio-cath BEFORE
+ PRIVATE $<$<CONFIG:Debug>:${warnings-c}> ${c99}
+)
add_executable(segyio-catb segyio-catb.c)
target_link_libraries(segyio-catb segyio apputils)
+target_compile_options(segyio-catb BEFORE
+ PRIVATE $<$<CONFIG:Debug>:${warnings-c}> ${c99}
+)
add_executable(segyio-catr segyio-catr.c)
target_link_libraries(segyio-catr segyio apputils)
+target_compile_options(segyio-catr BEFORE
+ PRIVATE $<$<CONFIG:Debug>:${warnings-c}> ${c99}
+)
add_executable(segyio-crop segyio-crop.c)
target_link_libraries(segyio-crop segyio apputils)
+target_compile_options(segyio-crop BEFORE
+ PRIVATE $<$<CONFIG:Debug>:${warnings-c}> ${c99}
+)
-install(TARGETS segyinfo DESTINATION ${CMAKE_INSTALL_PREFIX}/bin)
-install(TARGETS segyinspect DESTINATION ${CMAKE_INSTALL_PREFIX}/bin)
+install(TARGETS segyio-cath
+ segyio-catb
+ segyio-catr
+ segyio-crop
+ DESTINATION ${CMAKE_INSTALL_BINDIR})
-install(TARGETS segyio-cath DESTINATION ${CMAKE_INSTALL_BINDIR})
-install(TARGETS segyio-catb DESTINATION ${CMAKE_INSTALL_BINDIR})
-install(TARGETS segyio-catr DESTINATION ${CMAKE_INSTALL_BINDIR})
-install(TARGETS segyio-crop DESTINATION ${CMAKE_INSTALL_BINDIR})
+if (NOT BUILD_TESTING)
+ return ()
+endif ()
+
+set(small ${testdata}/small.sgy)
+add_test(NAME catr.arg.t COMMAND segyio-catr -t 5 ${small})
+add_test(NAME catr.arg.r1 COMMAND segyio-catr -r 5 ${small})
+add_test(NAME catr.arg.r2 COMMAND segyio-catr -r 1 2 ${small})
+add_test(NAME catr.arg.r3 COMMAND segyio-catr -r 1 2 3 ${small} -r 5 6)
+add_test(NAME catr.arg.multiple COMMAND segyio-catr "-r 1" 5 2 ${small} -r 1 6)
+add_test(NAME catr.arg.rt COMMAND segyio-catr -r 1 2 ${small} -t 5)
+
+add_test(NAME catb.arg.help COMMAND segyio-catb --help)
+add_test(NAME catb.fail.nosegy COMMAND segyio-catb ${CMAKE_CURRENT_LIST_FILE})
+add_test(NAME catb.fail.nofile COMMAND segyio-catb not-exist)
+add_test(NAME catb.fail.noarg COMMAND segyio-catb)
-add_python_test(applications.catr test/catr.py)
-add_python_test(applications.catb test/catb.py)
-add_python_test(applications.cath test/cath.py)
+add_test(NAME cath.arg.help COMMAND segyio-catb --help)
+add_test(NAME cath.fail.nosegy COMMAND segyio-catb ${CMAKE_CURRENT_LIST_FILE})
+add_test(NAME cath.fail.nofile COMMAND segyio-catb not-exist)
+add_test(NAME cath.fail.noarg COMMAND segyio-catb)
+
+set_tests_properties(catb.fail.nosegy
+ catb.fail.nofile
+ catb.fail.noarg
+ cath.fail.nosegy
+ cath.fail.nofile
+ cath.fail.noarg
+ PROPERTIES WILL_FAIL ON)
+
+find_package(PythonInterp)
+
+if (NOT PYTHON_EXECUTABLE)
+ message(WARNING "Could not find python, skipping application output tests")
+endif()
+set(test ${CMAKE_CURRENT_SOURCE_DIR}/test)
+add_test(NAME catr.output COMMAND ${PYTHON_EXECUTABLE} ${test}/catr.py)
+add_test(NAME catb.output COMMAND ${PYTHON_EXECUTABLE} ${test}/catb.py)
+add_test(NAME cath.output COMMAND ${PYTHON_EXECUTABLE} ${test}/cath.py)
diff --git a/applications/segyio-catb.c b/applications/segyio-catb.c
index c5b5770..c79ae48 100644
--- a/applications/segyio-catb.c
+++ b/applications/segyio-catb.c
@@ -38,8 +38,8 @@ static struct options parse_options( int argc, char** argv ){
opts.errmsg = NULL;
struct options opthelp, optversion;
- opthelp.help = 1, opthelp.errmsg = NULL;
- optversion.version = 1, optversion.errmsg = NULL;
+ opthelp.version = 0, opthelp.help = 1, opthelp.errmsg = NULL;
+ optversion.version = 1, optversion.help = 0, optversion.errmsg = NULL;
static struct option long_options[] = {
{"version", no_argument, 0, 'V'},
diff --git a/applications/segyio-crop.c b/applications/segyio-crop.c
index c1bb317..318b073 100644
--- a/applications/segyio-crop.c
+++ b/applications/segyio-crop.c
@@ -207,25 +207,25 @@ static struct options parse_options( int argc, char** argv ) {
optversion.version = 1, optversion.errmsg = NULL;
static struct option long_options[] = {
- { "iline-begin", required_argument, 0, 'i' },
- { "iline-end", required_argument, 0, 'I' },
- { "inline-begin", required_argument, 0, 'i' },
- { "inline-end", required_argument, 0, 'I' },
+ { "iline-begin", required_argument, 0, 'i' },
+ { "iline-end", required_argument, 0, 'I' },
+ { "inline-begin", required_argument, 0, 'i' },
+ { "inline-end", required_argument, 0, 'I' },
- { "xline-begin", required_argument, 0, 'x' },
- { "xline-end", required_argument, 0, 'X' },
- { "crossline-begin", required_argument, 0, 'x' },
- { "crossline-end", required_argument, 0, 'X' },
+ { "xline-begin", required_argument, 0, 'x' },
+ { "xline-end", required_argument, 0, 'X' },
+ { "crossline-begin", required_argument, 0, 'x' },
+ { "crossline-end", required_argument, 0, 'X' },
- { "sample-begin", required_argument, 0, 's' },
- { "sample-end", required_argument, 0, 'S' },
+ { "sample-begin", required_argument, 0, 's' },
+ { "sample-end", required_argument, 0, 'S' },
- { "il", required_argument, 0, 'b' },
- { "xl", required_argument, 0, 'B' },
+ { "il", required_argument, 0, 'b' },
+ { "xl", required_argument, 0, 'B' },
- { "verbose", no_argument, 0, 'v' },
- { "version", no_argument, 0, 'V' },
- { "help", no_argument, 0, 'h' },
+ { "verbose", no_argument, 0, 'v' },
+ { "version", no_argument, 0, 'V' },
+ { "help", no_argument, 0, 'h' },
{ 0, 0, 0, 0 }
};
diff --git a/applications/test/catb.py b/applications/test/catb.py
index 54a39b3..60219a4 100644
--- a/applications/test/catb.py
+++ b/applications/test/catb.py
@@ -40,11 +40,6 @@ class TestSegyB(unittest.TestCase):
cmd_base = './applications/segyio-catb'
FNULL = open(os.devnull, 'w')
- def test_help(self):
- cmd = self.cmd_base + ' --help'
- result = subprocess.check_output(cmd, shell=True, cwd=self.work_dir)
- self.assertEqual(result[0:18], b'Usage: segyio-catb')
-
def test_segy_in(self):
filepath = self.work_dir + '/python/test-data/small.sgy'
cmd = self.cmd_base + ' python/test-data/small.sgy'
@@ -53,31 +48,6 @@ class TestSegyB(unittest.TestCase):
for i in range(len(self.actual_output)):
self.assertEqual(result_list[i], self.actual_output[i])
- def test_non_segy_in(self):
- cmd = self.cmd_base + ' ../applications/CMakeLists.txt'
- result = subprocess.call(cmd,
- shell=True,
- stderr=self.FNULL,
- cwd=self.work_dir)
- self.assertEqual(result, 1)
-
- def test_none_file(self):
- cmd = self.cmd_base + ' nothing'
- result = subprocess.call(cmd,
- shell=True,
- stderr=self.FNULL,
- cwd=self.work_dir)
- self.assertEqual(result, 1)
-
- def test_empty_string_in(self):
- cmd = self.cmd_base + ' ';
- result = subprocess.call(cmd,
- shell=True,
- stderr=self.FNULL,
- stdout=self.FNULL,
- cwd=self.work_dir)
- self.assertEqual(result, 2)
-
if __name__ == '__main__':
unittest.main()
diff --git a/applications/test/cath.py b/applications/test/cath.py
index 206bd4d..713173d 100644
--- a/applications/test/cath.py
+++ b/applications/test/cath.py
@@ -24,12 +24,6 @@ class TestSegyH(unittest.TestCase):
cmd_base = './applications/segyio-cath'
FNULL = open(os.devnull, 'w')
- def test_help(self):
- cmd = self.cmd_base + ' --help'
- result = subprocess.check_output(cmd, shell=True, cwd=self.work_dir)
- self.assertEqual(result[0:18], b'Usage: segyio-cath')
-
-
def test_segy_in(self):
cmd = self.cmd_base + ' python/test-data/small.sgy'
result = subprocess.check_output(cmd, shell=True,
@@ -43,17 +37,5 @@ class TestSegyH(unittest.TestCase):
stderr=self.FNULL, cwd=self.work_dir)
self.assertEqual(result, 0)
- def test_none_file(self):
- cmd = self.cmd_base + ' nothing'
- result = subprocess.check_output(cmd, shell=True,
- stderr=self.FNULL, cwd=self.work_dir)
- self.assertEqual(result, b'')
-
- def test_empty_string_in(self):
- cmd = self.cmd_base + ' ';
- result = subprocess.call(cmd, shell=True, stderr=self.FNULL,
- stdout=self.FNULL, cwd=self.work_dir)
- self.assertEqual(result, 0)
-
if __name__ == '__main__':
unittest.main()
diff --git a/applications/test/catr.py b/applications/test/catr.py
index e08450f..4f447d7 100644
--- a/applications/test/catr.py
+++ b/applications/test/catr.py
@@ -1,8 +1,7 @@
-from unittest import TestCase
-
+import unittest
import subprocess
-class appTest(TestCase):
+class appTest(unittest.TestCase):
def setUp(self):
self.file_path = "../python/test-data/small.sgy"
self.cmd_base = ".././applications/segyio-catr"
@@ -99,30 +98,6 @@ class appTest(TestCase):
b'uint1\t0',
b'uint2\t0']
- def test_segycatr_argparse_t(self):
- cmd = [self.cmd_base, "-t 5", self.file_path]
- subprocess.check_call(cmd)
-
- def test_segycatr_argparse_r1(self):
- cmd = [self.cmd_base, "-r 5", self.file_path]
- subprocess.check_call(cmd)
-
- def test_segycatr_argparse_r2(self):
- cmd = [self.cmd_base, "-r 1 2", self.file_path]
- subprocess.check_call(cmd)
-
- def test_segycatr_argparse_r3(self):
- cmd = [self.cmd_base, "-r 1 2 3", self.file_path, "-r 5 6"]
- subprocess.check_call(cmd)
-
- def test_segycatr_argparse_r_multiple(self):
- cmd = [self.cmd_base, "-r 1", "5", "2", self.file_path, "-r 1 2"]
- subprocess.check_call(cmd)
-
- def test_segycatr_argparse_r_t(self):
- cmd = [self.cmd_base, "-r 1 2", self.file_path, "-t 5"]
- subprocess.check_call(cmd)
-
def test_segycatr_output_t(self):
cmd = [self.cmd_base, self.file_path, "-t 6"]
res = subprocess.Popen(cmd, stdout=subprocess.PIPE).communicate()[0]
@@ -164,3 +139,6 @@ class appTest(TestCase):
res_list = res.split(b"\n")
for i in range(len(self.ref_list)):
self.assertEquals(self.ref_list[i], res_list[i+182])
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/appveyor.yml b/appveyor.yml
index 8287c57..4b6a65a 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -40,6 +40,7 @@ install:
before_build:
- IF DEFINED PYTHON SET LANG=%LANG% -DPYTHON_EXECUTABLE=%PYTHON%\python
+ - git fetch --tags
# python extensions with setup.py typically requires building with the same
# compiler as python itself, but it seems that the extern C does a reasonable
@@ -54,28 +55,20 @@ build_script:
- cmake %APPVEYOR_BUILD_FOLDER% %W64% %MEX% %LANG% -DBUILD_SHARED_LIBS=%SHARED% -DCMAKE_INSTALL_PREFIX=%INSTALL_DIR%
- cmake --build . --config "%configuration%" --target install
- ctest -C "%configuration%" --output-on-failure
- - ps: pushd python
- - cat setup.py
- - IF DEFINED PYTHON python setup.py build_py
- - IF DEFINED PYTHON ( IF %PYTHON_VERSION% == 27
- cp segyio/_segyio.pyd build/*/segyio/
- )
- - IF DEFINED PYTHON python setup.py bdist_wheel
- ps: popd
+ - ps: pushd build/python
+ - IF DEFINED PYTHON python %APPVEYOR_BUILD_FOLDER%/setup.py bdist_wheel
- ps: popd
test_script:
- set PATH=%INSTALL_DIR%\bin;%PATH%
- - ps: pushd build
- - ctest -C %configuration% --output-on-failure
- - ps: pushd python
+ - ps: pushd build/python
- IF DEFINED PYTHON FOR /F "tokens=*" %%G IN ('dir /b dist\*.whl') DO
pip install dist/%%G
- ps: popd
- IF DEFINED PYTHON python -c
- "import segyio;f=segyio.open('python/test-data/small.sgy');print(f.ilines)"
- - ps: popd
- - IF DEFINED PYTHON python -m unittest discover -vs build/python/test -p *.py
+ "import segyio;f=segyio.open('test-data/small.sgy');print(f.ilines)"
+ - IF DEFINED PYTHON python python/examples/scan_min_max.py test-data/small.sgy
before_deploy:
- ps: pushd build/python
@@ -85,9 +78,13 @@ after_deploy:
deploy_script:
- ps: |
- If (-not ($env:APPVEYOR_REPO_TAG)) { return }
+ Write-Host "TAG: $env:APPVEYOR_REPO_TAG"
+ If (-not ($env:APPVEYOR_REPO_TAG).Value) { return }
+ Write-Host "SHARED: $env:SHARED"
If ($env:SHARED -eq "ON") { return }
+ Write-Host "BRANCH: $env:APPVEYOR_REPO_BRANCH"
If ($env:APPVEYOR_REPO_BRANCH -ne "master") { return }
+ Write-Host "Uploading wheels to pypi"
Invoke-Expression "twine upload -u statoil-travis -p $env:pypipassword --skip-existing dist/*"
If ($LastExitCode -ne 0) { $host.SetShouldExit($LastExitCode) }
diff --git a/changelog.md b/changelog.md
index 0726383..8bf3b01 100644
--- a/changelog.md
+++ b/changelog.md
@@ -1,10 +1,33 @@
+# 1.3.6
+* Applications no longer spuriously ignore arguments
+* All assertClose calls in tests have non-zero epsilon
+
+# 1.3.5
+* make install respects DESTDIR, also for python files
+
+# 1.3.4
+* Reading a slice in gather mode is significantly faster
+* Use ftello when available to support large files on systems where long is
+ 32-bit
+* The python extension is changed to use C++; a C++ compiler is now required,
+ not just optional, when building the python extension
+* Many internal and infrastructure improvements
+* The python library is built with setuptools - still integrated with cmake.
+ Users building from source can still do cmake && make
+* Git tag is now authority on version numbers, as opposed to the version string
+ recorded in the cmake file.
+* General building and infrastructure improvements
+
+# 1.3.3
+* Infrastructure fixes
+
# 1.3.2
-* add test for segy-cath
-* fix memory double-free error in subtr functions
+* Add test for segy-cath
+* Fix memory double-free error in subtr functions
# 1.3.1
-* fix a typo in segyio-crop --version
-* some building improvements
+* Fix a typo in segyio-crop --version
+* Some building improvements
# 1.3.0
* segyio is now meant to be used as proper versions, not trunk checkouts.
diff --git a/cmake/check_includes.cmake b/cmake/check_includes.cmake
deleted file mode 100644
index 6224c27..0000000
--- a/cmake/check_includes.cmake
+++ /dev/null
@@ -1,40 +0,0 @@
-include(CheckIncludeFile)
-include(CheckFunctionExists)
-
-# Portability checks; look for htons function
-check_include_file("netinet/in.h" HAVE_NETINET_IN_H)
-check_include_file("arpa/inet.h" HAVE_ARPA_INET_H)
-check_include_file("winsock2.h" HAVE_WINSOCK2_H)
-check_include_file("getopt.h" HAVE_GETOPT_H)
-check_function_exists(getopt_long HAVE_GETOPT_LONG)
-
-if (HAVE_NETINET_IN_H)
- add_definitions("-DHAVE_NETINET_IN_H")
-elseif (HAVE_ARPA_INET_H)
- add_definitions("-DHAVE_ARPA_INET_H")
-elseif (HAVE_WINSOCK2_H)
- set(ws2 ws2_32)
- add_definitions("-DHAVE_WINSOCK2_H")
-else()
- message(FATAL_ERROR "Could not find htons.")
-endif()
-
-check_include_file("sys/mman.h" HAVE_SYS_MMAN_H)
-if (HAVE_SYS_MMAN_H)
- add_definitions("-DHAVE_MMAP")
-endif()
-
-check_include_file("sys/stat.h" HAVE_SYS_STAT_H)
-if (HAVE_SYS_STAT_H)
- add_definitions("-DHAVE_SYS_STAT_H")
-
- check_function_exists(_fstati64 HAVE_FSTATI64)
- if (HAVE_FSTATI64)
- add_definitions("-DHAVE_FSTATI64")
- endif ()
-
- check_function_exists(_ftelli64 HAVE_FTELLI64)
- if (HAVE_FTELLI64)
- add_definitions("-DHAVE_FTELLI64")
- endif ()
-endif()
diff --git a/cmake/default_warnings.cmake b/cmake/default_warnings.cmake
deleted file mode 100644
index faf6f98..0000000
--- a/cmake/default_warnings.cmake
+++ /dev/null
@@ -1,9 +0,0 @@
-if (NOT MSVC)
- # assuming gcc-style options
- set(C_WARNINGS "-Wall -Wextra -pedantic -Wformat-nonliteral -Wcast-align -Wpointer-arith -Wmissing-declarations -Wcast-qual -Wshadow -Wwrite-strings -Wchar-subscripts -Wredundant-decls")
- set(CMAKE_C_FLAGS_DEBUG "${C_WARNINGS} ${CMAKE_C_FLAGS_DEBUG}")
- set(CMAKE_C_FLAGS_RELWITHDEBINFO "${C_WARNINGS} ${CMAKE_C_FLAGS_RELWITHDEBINFO}")
-else()
- add_definitions("/W3 /wd4996")
-endif ()
-
diff --git a/cmake/segyio_testing.cmake b/cmake/segyio_testing.cmake
deleted file mode 100644
index 7aede08..0000000
--- a/cmake/segyio_testing.cmake
+++ /dev/null
@@ -1,32 +0,0 @@
-function(to_path_list var path1)
- if("${CMAKE_HOST_SYSTEM}" MATCHES ".*Windows.*")
- set(sep "\\;")
- else()
- set(sep ":")
- endif()
- set(result "${path1}") # First element doesn't require separator at all...
- foreach(path ${ARGN})
- set(result "${result}${sep}${path}") # .. but other elements do.
- endforeach()
- set(${var} "${result}" PARENT_SCOPE)
-endfunction()
-
-function(add_memcheck_test NAME BINARY)
- # Valgrind on MacOS is experimental
- if(LINUX AND (${CMAKE_BUILD_TYPE} MATCHES "DEBUG"))
- set(memcheck_command "valgrind --trace-children=yes --leak-check=full --error-exitcode=31415")
- separate_arguments(memcheck_command)
- add_test(memcheck_${NAME} ${memcheck_command} ./${BINARY})
- endif()
-endfunction(add_memcheck_test)
-
-function(add_segyio_test TESTNAME TEST_SOURCES)
- if(NOT MSVC)
- set(MATH_LIB "m")
- endif()
- add_executable(test_${TESTNAME} unittest.h "${TEST_SOURCES}")
- target_link_libraries(test_${TESTNAME} segyio-static ${MATH_LIB})
- add_dependencies(test_${TESTNAME} segyio-static)
- add_test(NAME ${TESTNAME} COMMAND ${EXECUTABLE_OUTPUT_PATH}/test_${TESTNAME})
- add_memcheck_test(${TESTNAME} ${EXECUTABLE_OUTPUT_PATH}/test_${TESTNAME})
-endfunction()
diff --git a/config.sh b/config.sh
index 0323392..c546e1e 100644
--- a/config.sh
+++ b/config.sh
@@ -1,5 +1,26 @@
function run_tests {
+ set -x
python -c "import segyio; print(segyio.__version__)"
- cp -r ../test-data .
- python -m unittest discover -vs ../python/test -p "*.py"
+ python ../python/examples/scan_min_max.py ../test-data/small.sgy
+}
+
+
+function pre_build {
+ if [ -n "$IS_OSX" ]; then return; fi
+ if [ -d build-centos5 ]; then return; fi
+
+ # the cmakes available in yum for centos5 are too old (latest 2.11.x), so
+ # do a dirty hack and get a pre-compiled i386-binary from cmake.org and run
+ # it. it's only necessary in the multilinux docker container and hopefully
+ # only until multilinux2 images are released
+
+ mkdir build-centos5
+ pushd build-centos5
+ export cmake=cmake-2.8.12.2-Linux-i386
+ wget --no-check-certificate https://cmake.org/files/v2.8/cmake-2.8.12.2-Linux-i386.tar.gz
+ tar xzvf $cmake.tar.gz
+ ./$cmake/bin/cmake --version
+ ./$cmake/bin/cmake .. -DBUILD_PYTHON=OFF -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=ON
+ make install
+ popd
}
diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt
index 2dc87ac..5a268b1 100644
--- a/lib/CMakeLists.txt
+++ b/lib/CMakeLists.txt
@@ -1,28 +1,25 @@
-project(libsegyio)
-
-if (NOT MSVC)
- set(CMAKE_C_FLAGS "-std=c99 ${CMAKE_C_FLAGS}")
-endif()
+project(libsegyio C)
set(SOURCE_FILES src/segy.c)
set(STATIC_NAME segyio)
-if(WINDOWS)
+if(MSVC)
# MSVC outputs the same name for static and shared libraries (with the same
# extension), so we need to differentiate between the two somehow.
set(STATIC_NAME "${STATIC_NAME}-static")
set(DLL_EXPORT_FILES src/segy.def)
endif()
-if(NOT MSVC)
- set(math "m")
-endif()
-
#
# static build
#
add_library(segyio-static STATIC ${SOURCE_FILES})
-target_link_libraries(segyio-static ${math} ${ws2})
+target_link_libraries(segyio-static ${m} ${ws2})
+target_compile_definitions(segyio-static PRIVATE
+ ${htons} ${mmap} ${fstat} ${ftello})
+target_compile_options(segyio-static BEFORE
+ PRIVATE $<$<CONFIG:Debug>:${warnings-c}> ${c99}
+)
set_target_properties(segyio-static PROPERTIES
OUTPUT_NAME ${STATIC_NAME}
CLEAN_DIRECT_OUTPUT 1)
@@ -36,7 +33,12 @@ target_include_directories(
# dynamic build
#
add_library(segyio-shared SHARED ${SOURCE_FILES} ${DLL_EXPORT_FILES})
-target_link_libraries(segyio-shared ${math} ${ws2})
+target_link_libraries(segyio-shared ${m} ${ws2})
+target_compile_options(segyio-shared BEFORE
+ PRIVATE $<$<CONFIG:Debug>:${warnings-c}> ${c99}
+)
+target_compile_definitions(segyio-shared PRIVATE
+ ${htons} ${mmap} ${fstat} ${ftello})
set_target_properties(segyio-shared PROPERTIES
SOVERSION ${segyio_MAJOR}
VERSION ${segyio_MAJOR}
@@ -76,8 +78,8 @@ configure_file(${testdata}/text.sgy test-data/text.sgy COPYONLY)
foreach (src segy utils)
add_executable(test${src} test/${src}.c)
+ target_compile_options(test${src} BEFORE PRIVATE ${c99})
target_link_libraries(test${src} segyio-shared)
target_include_directories(test${src} PRIVATE src)
add_test(c.${src} test${src})
- add_memcheck_test(test${src} test${src})
endforeach()
diff --git a/lib/src/segy.c b/lib/src/segy.c
index c5750b9..52491b3 100644
--- a/lib/src/segy.c
+++ b/lib/src/segy.c
@@ -1,5 +1,9 @@
#define _POSIX_SOURCE /* fileno */
+/* 64-bit off_t in ftello */
+#define _POSIX_C_SOURCE 200808L
+#define _FILE_OFFSET_BITS 64
+
#ifdef HAVE_MMAP
#define _POSIX_SOURCE
#include <sys/mman.h>
@@ -400,14 +404,16 @@ int segy_flush( segy_file* fp, bool async ) {
}
long long segy_ftell( segy_file* fp ) {
-#ifdef HAVE_FTELLI64
+#ifdef HAVE_FTELLO
+ off_t pos = ftello( fp->fp );
+ assert( pos != -1 );
+ return pos;
+#elif HAVE_FTELLI64
// assuming we're on windows. This function is a little rough, but only
// meant for testing - it's not a part of the public interface.
return _ftelli64( fp->fp );
#else
- // cppcheck-suppress duplicateExpression
- assert( sizeof( long ) == sizeof( long long ) );
- return ftell( fp->fp );
+ assert( false );
#endif
}
diff --git a/lib/test/segy.c b/lib/test/segy.c
index e7de8df..e1ac670 100644
--- a/lib/test/segy.c
+++ b/lib/test/segy.c
@@ -544,7 +544,7 @@ static void testReadInLine_4(){
//last xline
int last_line = (crosslines_sz-1);
//first sample
- assertClose(4.24f, data[samples*last_line+0], 0);
+ assertClose(4.24f, data[samples*last_line+0], 0.0001f);
//middle sample
assertClose(4.24024f, data[samples*last_line+samples/2-1], 0.0001);
//last sample
@@ -878,6 +878,7 @@ static void test_file_size_above_4GB(){
long long pos = segy_ftell( fp );
assertTrue(pos > (long long)INT_MAX, "pos smaller than INT_MAX. "
"This means there's an overflow somewhere" );
+ assertTrue(pos != -1, "overflow in off_t");
assertTrue(pos == trace * tracesize, "seek overflow");
segy_close(fp);
}
diff --git a/mex/CMakeLists.txt b/mex/CMakeLists.txt
index 66bb167..2a1a665 100644
--- a/mex/CMakeLists.txt
+++ b/mex/CMakeLists.txt
@@ -9,7 +9,7 @@ if (NOT BUILD_MEX)
return()
endif()
-include(${CMAKE_SOURCE_DIR}/cmake/matlab.cmake REQUIRED)
+include(matlab.cmake REQUIRED)
option(BUILD_MEX_TESTS "Build matlab mex tests" ON)
diff --git a/cmake/matlab.cmake b/mex/matlab.cmake
similarity index 100%
rename from cmake/matlab.cmake
rename to mex/matlab.cmake
diff --git a/pycmake/.travis.yml b/pycmake/.travis.yml
deleted file mode 100644
index ec40628..0000000
--- a/pycmake/.travis.yml
+++ /dev/null
@@ -1,21 +0,0 @@
-dist: trusty
-language: python
-
-script:
- - git clone https://github.com/statoil/segyio
- - git clone https://github.com/statoil/libecl
- - mkdir segyio-build libecl-build
- - pushd segyio-build
- - cmake $TRAVIS_BUILD_DIR/segyio
- -DBUILD_PYTHON=ON
- -DCMAKE_MODULE_PATH=$TRAVIS_BUILD_DIR
- -DCMAKE_INSTALL_PREFIX=`pwd`
- - make -j2 install
- - popd
- - pushd libecl-build
- - cmake $TRAVIS_BUILD_DIR/libecl
- -DBUILD_PYTHON=ON
- -DCMAKE_MODULE_PATH=$TRAVIS_BUILD_DIR
- -DCMAKE_INSTALL_PREFIX=`pwd`
- - make -j2 install
- - popd
diff --git a/pycmake/CMakeLists.txt b/pycmake/CMakeLists.txt
deleted file mode 100644
index 21291fa..0000000
--- a/pycmake/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-cmake_minimum_required( VERSION 2.0 )
-project( pycmake )
-
-if(PYCMAKE_ENABLE_TESTING)
- add_subdirectory(test)
-endif()
-
-install(FILES FindPythonModule.cmake
- PythonPackage.cmake
- DESTINATION share/cmake/Modules)
diff --git a/pycmake/FindPythonModule.cmake b/pycmake/FindPythonModule.cmake
deleted file mode 100644
index e3c830c..0000000
--- a/pycmake/FindPythonModule.cmake
+++ /dev/null
@@ -1,168 +0,0 @@
-# Copyright (C) 2016 Statoil ASA, Norway.
-#
-# This file is part of ERT - Ensemble based Reservoir Tool.
-#
-# ERT is free software: you can redistribute it and/or modify it under the
-# terms of the GNU General Public License as published by the Free Software
-# Foundation, either version 3 of the License, or (at your option) any later
-# version.
-#
-# ERT is distributed in the hope that it will be useful, but WITHOUT ANY
-# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-# A PARTICULAR PURPOSE.
-#
-# See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
-# for more details
-
-
-
-# The basic assumption of this package is PEP 396 -- Module Version Numbers as
-# layed out in https://www.python.org/dev/peps/pep-0396/
-
-# Unfortunately, not all Python modules expose a version number, like inspect.
-# Other Python modules expose several version numbers, e.g. one for the
-# underlying software and one for the python packaging, like SQLite and PyQt.
-
-cmake_minimum_required (VERSION 2.8.1)
-
-
-
-# try import python module, if success, check its version, store as PY_module.
-# the module is imported as-is, hence the case (e.g. PyQt4) must be correct.
-#
-# if given a second argument, the accessor, we call accessor on the module
-# instead of the default __version__.
-#
-# (Yes, accessor could potentially be a function like "os.delete_everything()".)
-macro(python_module_version module)
- set(PY_VERSION_ACCESSOR "__version__")
- set(PY_module_name ${module})
-
- if(${PY_module_name} STREQUAL "PyQt4")
- set(PY_module_name "PyQt4.Qt")
- endif()
- if(${PY_module_name} STREQUAL "PyQt4.Qt")
- set(PY_VERSION_ACCESSOR "PYQT_VERSION_STR")
- endif()
-
- if(${PY_module_name} STREQUAL "serial")
- set(PY_VERSION_ACCESSOR "VERSION")
- endif()
-
- if(${PY_module_name} STREQUAL "sqlite")
- set(PY_VERSION_ACCESSOR "version")
- endif()
-
-
- # ARGUMENTS: module accessor
- set (extra_macro_args ${ARGN})
- list(LENGTH extra_macro_args num_extra_args)
- if (${num_extra_args} GREATER 0)
- list(GET extra_macro_args 0 accessor)
- set(PY_VERSION_ACCESSOR ${accessor})
- endif()
-
- execute_process(COMMAND "${PYTHON_EXECUTABLE}" "-c"
- "# set module's version to py_mv and print it
-import ${PY_module_name} as py_m
-py_mv = '0.0.0' # output if no accessor is found
-if hasattr(py_m, '${PY_VERSION_ACCESSOR}'):
- py_mv = py_m.${PY_VERSION_ACCESSOR}
-print(py_mv)
-"
- RESULT_VARIABLE _${module}_fail # error code 0 if module is importable
- OUTPUT_VARIABLE _${module}_version # module.accessor or "0.0.0" if no such
- ERROR_VARIABLE stderr_output
- OUTPUT_STRIP_TRAILING_WHITESPACE)
- if(NOT _${module}_fail)
- set(PY_${module} ${_${module}_version})
- endif()
-
- # clean up
- unset(PY_VERSION_ACCESSOR)
- unset(PY_module_name)
- unset(extra_macro_args)
-endmacro()
-
-
-
-# If we find the correct module and new enough version, set PY_package, where
-# "package" is the given argument to the version we found else, display warning
-# and do not set any variables.
-macro(python_module package)
-
- # ARGUMENTS: package package_req module_version version_req accessor
- set (extra_macro_args ${ARGN})
- # Did we get any optional args?
- list(LENGTH extra_macro_args num_extra_args)
- if (${num_extra_args} GREATER 0)
- list(GET extra_macro_args 0 package_req)
- else()
- set(package_req "REQUIRED") # requirement not set, is required
- endif ()
- if (${num_extra_args} GREATER 1)
- list(GET extra_macro_args 1 module_version)
- else()
- set(module_version "0.0.0") # module_version not set, 0.0.0 is ok
- endif ()
- if (${num_extra_args} GREATER 2)
- list(GET extra_macro_args 2 version_req)
- else()
- set(version_req "MINIMUM") # version requirement not set, is minimum
- endif ()
- if (${num_extra_args} GREATER 3)
- list(GET extra_macro_args 3 accessor)
- endif ()
-
- # Setting warning/error output level
- set(PY_MSG_ERR SEND_ERROR)
- set(PY_MSG_WARN WARNING)
- if(${package_req} STREQUAL "QUIET")
- set(PY_MSG_ERR STATUS)
- set(PY_MSG_WARN STATUS)
- endif()
-
- # We are done expanding the optional arguments
-
- python_module_version(${package} ${accessor})
-
- # package not found in system
- if(NOT DEFINED PY_${package})
- if(${package_req} STREQUAL "OPTIONAL")
- message(${PY_MSG_WARN} "Could not find Python module " ${package})
- else()
- message(${PY_MSG_ERR} "Could not find Python module " ${package})
- endif()
-
- else()
- # package found in system
-
- if (${version_req} STREQUAL "EXACT" AND NOT ${PY_${package}} VERSION_EQUAL ${module_version})
- message(${PY_MSG_ERR} "Python module ${package} not exact. "
- "Wanted EXACT ${module_version}, found ${PY_${package}}")
- elseif (${version_req} STREQUAL "OPTIONAL" AND ${PY_${package}} VERSION_LESS ${module_version})
- message(${PY_MSG_WARN} "Python module ${package} too old. "
- "Wanted ${module_version}, found ${PY_${package}}")
- elseif (${version_req} STREQUAL "MINIMUM" AND ${PY_${package}} VERSION_LESS ${module_version})
- message(${PY_MSG_ERR} "Python module ${package} too old. "
- "Wanted MINIMUM ${module_version}, found ${PY_${package}}")
- else()
- if(NOT DEFINED accessor)
- message(STATUS "Found ${package}. "
- "${PY_${package}} >= ${module_version}")
- else()
- message(STATUS "Found ${package}. "
- "${PY_${package}} >= ${module_version} (" ${accessor} ")")
- endif()
- endif()
- endif()
-
- # clean up
- unset(package_req)
- unset(module_version)
- unset(version_req)
- unset(accessor)
- unset(extra_macro_args)
- set(PY_MSG_ERR)
- set(PY_MSG_WARN)
-endmacro()
diff --git a/pycmake/LICENSE b/pycmake/LICENSE
deleted file mode 100644
index 9cecc1d..0000000
--- a/pycmake/LICENSE
+++ /dev/null
@@ -1,674 +0,0 @@
- GNU GENERAL PUBLIC LICENSE
- Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
- Preamble
-
- The GNU General Public License is a free, copyleft license for
-software and other kinds of works.
-
- The licenses for most software and other practical works are designed
-to take away your freedom to share and change the works. By contrast,
-the GNU General Public License is intended to guarantee your freedom to
-share and change all versions of a program--to make sure it remains free
-software for all its users. We, the Free Software Foundation, use the
-GNU General Public License for most of our software; it applies also to
-any other work released this way by its authors. You can apply it to
-your programs, too.
-
- When we speak of free software, we are referring to freedom, not
-price. Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-them if you wish), that you receive source code or can get it if you
-want it, that you can change the software or use pieces of it in new
-free programs, and that you know you can do these things.
-
- To protect your rights, we need to prevent others from denying you
-these rights or asking you to surrender the rights. Therefore, you have
-certain responsibilities if you distribute copies of the software, or if
-you modify it: responsibilities to respect the freedom of others.
-
- For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must pass on to the recipients the same
-freedoms that you received. You must make sure that they, too, receive
-or can get the source code. And you must show them these terms so they
-know their rights.
-
- Developers that use the GNU GPL protect your rights with two steps:
-(1) assert copyright on the software, and (2) offer you this License
-giving you legal permission to copy, distribute and/or modify it.
-
- For the developers' and authors' protection, the GPL clearly explains
-that there is no warranty for this free software. For both users' and
-authors' sake, the GPL requires that modified versions be marked as
-changed, so that their problems will not be attributed erroneously to
-authors of previous versions.
-
- Some devices are designed to deny users access to install or run
-modified versions of the software inside them, although the manufacturer
-can do so. This is fundamentally incompatible with the aim of
-protecting users' freedom to change the software. The systematic
-pattern of such abuse occurs in the area of products for individuals to
-use, which is precisely where it is most unacceptable. Therefore, we
-have designed this version of the GPL to prohibit the practice for those
-products. If such problems arise substantially in other domains, we
-stand ready to extend this provision to those domains in future versions
-of the GPL, as needed to protect the freedom of users.
-
- Finally, every program is threatened constantly by software patents.
-States should not allow patents to restrict development and use of
-software on general-purpose computers, but in those that do, we wish to
-avoid the special danger that patents applied to a free program could
-make it effectively proprietary. To prevent this, the GPL assures that
-patents cannot be used to render the program non-free.
-
- The precise terms and conditions for copying, distribution and
-modification follow.
-
- TERMS AND CONDITIONS
-
- 0. Definitions.
-
- "This License" refers to version 3 of the GNU General Public License.
-
- "Copyright" also means copyright-like laws that apply to other kinds of
-works, such as semiconductor masks.
-
- "The Program" refers to any copyrightable work licensed under this
-License. Each licensee is addressed as "you". "Licensees" and
-"recipients" may be individuals or organizations.
-
- To "modify" a work means to copy from or adapt all or part of the work
-in a fashion requiring copyright permission, other than the making of an
-exact copy. The resulting work is called a "modified version" of the
-earlier work or a work "based on" the earlier work.
-
- A "covered work" means either the unmodified Program or a work based
-on the Program.
-
- To "propagate" a work means to do anything with it that, without
-permission, would make you directly or secondarily liable for
-infringement under applicable copyright law, except executing it on a
-computer or modifying a private copy. Propagation includes copying,
-distribution (with or without modification), making available to the
-public, and in some countries other activities as well.
-
- To "convey" a work means any kind of propagation that enables other
-parties to make or receive copies. Mere interaction with a user through
-a computer network, with no transfer of a copy, is not conveying.
-
- An interactive user interface displays "Appropriate Legal Notices"
-to the extent that it includes a convenient and prominently visible
-feature that (1) displays an appropriate copyright notice, and (2)
-tells the user that there is no warranty for the work (except to the
-extent that warranties are provided), that licensees may convey the
-work under this License, and how to view a copy of this License. If
-the interface presents a list of user commands or options, such as a
-menu, a prominent item in the list meets this criterion.
-
- 1. Source Code.
-
- The "source code" for a work means the preferred form of the work
-for making modifications to it. "Object code" means any non-source
-form of a work.
-
- A "Standard Interface" means an interface that either is an official
-standard defined by a recognized standards body, or, in the case of
-interfaces specified for a particular programming language, one that
-is widely used among developers working in that language.
-
- The "System Libraries" of an executable work include anything, other
-than the work as a whole, that (a) is included in the normal form of
-packaging a Major Component, but which is not part of that Major
-Component, and (b) serves only to enable use of the work with that
-Major Component, or to implement a Standard Interface for which an
-implementation is available to the public in source code form. A
-"Major Component", in this context, means a major essential component
-(kernel, window system, and so on) of the specific operating system
-(if any) on which the executable work runs, or a compiler used to
-produce the work, or an object code interpreter used to run it.
-
- The "Corresponding Source" for a work in object code form means all
-the source code needed to generate, install, and (for an executable
-work) run the object code and to modify the work, including scripts to
-control those activities. However, it does not include the work's
-System Libraries, or general-purpose tools or generally available free
-programs which are used unmodified in performing those activities but
-which are not part of the work. For example, Corresponding Source
-includes interface definition files associated with source files for
-the work, and the source code for shared libraries and dynamically
-linked subprograms that the work is specifically designed to require,
-such as by intimate data communication or control flow between those
-subprograms and other parts of the work.
-
- The Corresponding Source need not include anything that users
-can regenerate automatically from other parts of the Corresponding
-Source.
-
- The Corresponding Source for a work in source code form is that
-same work.
-
- 2. Basic Permissions.
-
- All rights granted under this License are granted for the term of
-copyright on the Program, and are irrevocable provided the stated
-conditions are met. This License explicitly affirms your unlimited
-permission to run the unmodified Program. The output from running a
-covered work is covered by this License only if the output, given its
-content, constitutes a covered work. This License acknowledges your
-rights of fair use or other equivalent, as provided by copyright law.
-
- You may make, run and propagate covered works that you do not
-convey, without conditions so long as your license otherwise remains
-in force. You may convey covered works to others for the sole purpose
-of having them make modifications exclusively for you, or provide you
-with facilities for running those works, provided that you comply with
-the terms of this License in conveying all material for which you do
-not control copyright. Those thus making or running the covered works
-for you must do so exclusively on your behalf, under your direction
-and control, on terms that prohibit them from making any copies of
-your copyrighted material outside their relationship with you.
-
- Conveying under any other circumstances is permitted solely under
-the conditions stated below. Sublicensing is not allowed; section 10
-makes it unnecessary.
-
- 3. Protecting Users' Legal Rights From Anti-Circumvention Law.
-
- No covered work shall be deemed part of an effective technological
-measure under any applicable law fulfilling obligations under article
-11 of the WIPO copyright treaty adopted on 20 December 1996, or
-similar laws prohibiting or restricting circumvention of such
-measures.
-
- When you convey a covered work, you waive any legal power to forbid
-circumvention of technological measures to the extent such circumvention
-is effected by exercising rights under this License with respect to
-the covered work, and you disclaim any intention to limit operation or
-modification of the work as a means of enforcing, against the work's
-users, your or third parties' legal rights to forbid circumvention of
-technological measures.
-
- 4. Conveying Verbatim Copies.
-
- You may convey verbatim copies of the Program's source code as you
-receive it, in any medium, provided that you conspicuously and
-appropriately publish on each copy an appropriate copyright notice;
-keep intact all notices stating that this License and any
-non-permissive terms added in accord with section 7 apply to the code;
-keep intact all notices of the absence of any warranty; and give all
-recipients a copy of this License along with the Program.
-
- You may charge any price or no price for each copy that you convey,
-and you may offer support or warranty protection for a fee.
-
- 5. Conveying Modified Source Versions.
-
- You may convey a work based on the Program, or the modifications to
-produce it from the Program, in the form of source code under the
-terms of section 4, provided that you also meet all of these conditions:
-
- a) The work must carry prominent notices stating that you modified
- it, and giving a relevant date.
-
- b) The work must carry prominent notices stating that it is
- released under this License and any conditions added under section
- 7. This requirement modifies the requirement in section 4 to
- "keep intact all notices".
-
- c) You must license the entire work, as a whole, under this
- License to anyone who comes into possession of a copy. This
- License will therefore apply, along with any applicable section 7
- additional terms, to the whole of the work, and all its parts,
- regardless of how they are packaged. This License gives no
- permission to license the work in any other way, but it does not
- invalidate such permission if you have separately received it.
-
- d) If the work has interactive user interfaces, each must display
- Appropriate Legal Notices; however, if the Program has interactive
- interfaces that do not display Appropriate Legal Notices, your
- work need not make them do so.
-
- A compilation of a covered work with other separate and independent
-works, which are not by their nature extensions of the covered work,
-and which are not combined with it such as to form a larger program,
-in or on a volume of a storage or distribution medium, is called an
-"aggregate" if the compilation and its resulting copyright are not
-used to limit the access or legal rights of the compilation's users
-beyond what the individual works permit. Inclusion of a covered work
-in an aggregate does not cause this License to apply to the other
-parts of the aggregate.
-
- 6. Conveying Non-Source Forms.
-
- You may convey a covered work in object code form under the terms
-of sections 4 and 5, provided that you also convey the
-machine-readable Corresponding Source under the terms of this License,
-in one of these ways:
-
- a) Convey the object code in, or embodied in, a physical product
- (including a physical distribution medium), accompanied by the
- Corresponding Source fixed on a durable physical medium
- customarily used for software interchange.
-
- b) Convey the object code in, or embodied in, a physical product
- (including a physical distribution medium), accompanied by a
- written offer, valid for at least three years and valid for as
- long as you offer spare parts or customer support for that product
- model, to give anyone who possesses the object code either (1) a
- copy of the Corresponding Source for all the software in the
- product that is covered by this License, on a durable physical
- medium customarily used for software interchange, for a price no
- more than your reasonable cost of physically performing this
- conveying of source, or (2) access to copy the
- Corresponding Source from a network server at no charge.
-
- c) Convey individual copies of the object code with a copy of the
- written offer to provide the Corresponding Source. This
- alternative is allowed only occasionally and noncommercially, and
- only if you received the object code with such an offer, in accord
- with subsection 6b.
-
- d) Convey the object code by offering access from a designated
- place (gratis or for a charge), and offer equivalent access to the
- Corresponding Source in the same way through the same place at no
- further charge. You need not require recipients to copy the
- Corresponding Source along with the object code. If the place to
- copy the object code is a network server, the Corresponding Source
- may be on a different server (operated by you or a third party)
- that supports equivalent copying facilities, provided you maintain
- clear directions next to the object code saying where to find the
- Corresponding Source. Regardless of what server hosts the
- Corresponding Source, you remain obligated to ensure that it is
- available for as long as needed to satisfy these requirements.
-
- e) Convey the object code using peer-to-peer transmission, provided
- you inform other peers where the object code and Corresponding
- Source of the work are being offered to the general public at no
- charge under subsection 6d.
-
- A separable portion of the object code, whose source code is excluded
-from the Corresponding Source as a System Library, need not be
-included in conveying the object code work.
-
- A "User Product" is either (1) a "consumer product", which means any
-tangible personal property which is normally used for personal, family,
-or household purposes, or (2) anything designed or sold for incorporation
-into a dwelling. In determining whether a product is a consumer product,
-doubtful cases shall be resolved in favor of coverage. For a particular
-product received by a particular user, "normally used" refers to a
-typical or common use of that class of product, regardless of the status
-of the particular user or of the way in which the particular user
-actually uses, or expects or is expected to use, the product. A product
-is a consumer product regardless of whether the product has substantial
-commercial, industrial or non-consumer uses, unless such uses represent
-the only significant mode of use of the product.
-
- "Installation Information" for a User Product means any methods,
-procedures, authorization keys, or other information required to install
-and execute modified versions of a covered work in that User Product from
-a modified version of its Corresponding Source. The information must
-suffice to ensure that the continued functioning of the modified object
-code is in no case prevented or interfered with solely because
-modification has been made.
-
- If you convey an object code work under this section in, or with, or
-specifically for use in, a User Product, and the conveying occurs as
-part of a transaction in which the right of possession and use of the
-User Product is transferred to the recipient in perpetuity or for a
-fixed term (regardless of how the transaction is characterized), the
-Corresponding Source conveyed under this section must be accompanied
-by the Installation Information. But this requirement does not apply
-if neither you nor any third party retains the ability to install
-modified object code on the User Product (for example, the work has
-been installed in ROM).
-
- The requirement to provide Installation Information does not include a
-requirement to continue to provide support service, warranty, or updates
-for a work that has been modified or installed by the recipient, or for
-the User Product in which it has been modified or installed. Access to a
-network may be denied when the modification itself materially and
-adversely affects the operation of the network or violates the rules and
-protocols for communication across the network.
-
- Corresponding Source conveyed, and Installation Information provided,
-in accord with this section must be in a format that is publicly
-documented (and with an implementation available to the public in
-source code form), and must require no special password or key for
-unpacking, reading or copying.
-
- 7. Additional Terms.
-
- "Additional permissions" are terms that supplement the terms of this
-License by making exceptions from one or more of its conditions.
-Additional permissions that are applicable to the entire Program shall
-be treated as though they were included in this License, to the extent
-that they are valid under applicable law. If additional permissions
-apply only to part of the Program, that part may be used separately
-under those permissions, but the entire Program remains governed by
-this License without regard to the additional permissions.
-
- When you convey a copy of a covered work, you may at your option
-remove any additional permissions from that copy, or from any part of
-it. (Additional permissions may be written to require their own
-removal in certain cases when you modify the work.) You may place
-additional permissions on material, added by you to a covered work,
-for which you have or can give appropriate copyright permission.
-
- Notwithstanding any other provision of this License, for material you
-add to a covered work, you may (if authorized by the copyright holders of
-that material) supplement the terms of this License with terms:
-
- a) Disclaiming warranty or limiting liability differently from the
- terms of sections 15 and 16 of this License; or
-
- b) Requiring preservation of specified reasonable legal notices or
- author attributions in that material or in the Appropriate Legal
- Notices displayed by works containing it; or
-
- c) Prohibiting misrepresentation of the origin of that material, or
- requiring that modified versions of such material be marked in
- reasonable ways as different from the original version; or
-
- d) Limiting the use for publicity purposes of names of licensors or
- authors of the material; or
-
- e) Declining to grant rights under trademark law for use of some
- trade names, trademarks, or service marks; or
-
- f) Requiring indemnification of licensors and authors of that
- material by anyone who conveys the material (or modified versions of
- it) with contractual assumptions of liability to the recipient, for
- any liability that these contractual assumptions directly impose on
- those licensors and authors.
-
- All other non-permissive additional terms are considered "further
-restrictions" within the meaning of section 10. If the Program as you
-received it, or any part of it, contains a notice stating that it is
-governed by this License along with a term that is a further
-restriction, you may remove that term. If a license document contains
-a further restriction but permits relicensing or conveying under this
-License, you may add to a covered work material governed by the terms
-of that license document, provided that the further restriction does
-not survive such relicensing or conveying.
-
- If you add terms to a covered work in accord with this section, you
-must place, in the relevant source files, a statement of the
-additional terms that apply to those files, or a notice indicating
-where to find the applicable terms.
-
- Additional terms, permissive or non-permissive, may be stated in the
-form of a separately written license, or stated as exceptions;
-the above requirements apply either way.
-
- 8. Termination.
-
- You may not propagate or modify a covered work except as expressly
-provided under this License. Any attempt otherwise to propagate or
-modify it is void, and will automatically terminate your rights under
-this License (including any patent licenses granted under the third
-paragraph of section 11).
-
- However, if you cease all violation of this License, then your
-license from a particular copyright holder is reinstated (a)
-provisionally, unless and until the copyright holder explicitly and
-finally terminates your license, and (b) permanently, if the copyright
-holder fails to notify you of the violation by some reasonable means
-prior to 60 days after the cessation.
-
- Moreover, your license from a particular copyright holder is
-reinstated permanently if the copyright holder notifies you of the
-violation by some reasonable means, this is the first time you have
-received notice of violation of this License (for any work) from that
-copyright holder, and you cure the violation prior to 30 days after
-your receipt of the notice.
-
- Termination of your rights under this section does not terminate the
-licenses of parties who have received copies or rights from you under
-this License. If your rights have been terminated and not permanently
-reinstated, you do not qualify to receive new licenses for the same
-material under section 10.
-
- 9. Acceptance Not Required for Having Copies.
-
- You are not required to accept this License in order to receive or
-run a copy of the Program. Ancillary propagation of a covered work
-occurring solely as a consequence of using peer-to-peer transmission
-to receive a copy likewise does not require acceptance. However,
-nothing other than this License grants you permission to propagate or
-modify any covered work. These actions infringe copyright if you do
-not accept this License. Therefore, by modifying or propagating a
-covered work, you indicate your acceptance of this License to do so.
-
- 10. Automatic Licensing of Downstream Recipients.
-
- Each time you convey a covered work, the recipient automatically
-receives a license from the original licensors, to run, modify and
-propagate that work, subject to this License. You are not responsible
-for enforcing compliance by third parties with this License.
-
- An "entity transaction" is a transaction transferring control of an
-organization, or substantially all assets of one, or subdividing an
-organization, or merging organizations. If propagation of a covered
-work results from an entity transaction, each party to that
-transaction who receives a copy of the work also receives whatever
-licenses to the work the party's predecessor in interest had or could
-give under the previous paragraph, plus a right to possession of the
-Corresponding Source of the work from the predecessor in interest, if
-the predecessor has it or can get it with reasonable efforts.
-
- You may not impose any further restrictions on the exercise of the
-rights granted or affirmed under this License. For example, you may
-not impose a license fee, royalty, or other charge for exercise of
-rights granted under this License, and you may not initiate litigation
-(including a cross-claim or counterclaim in a lawsuit) alleging that
-any patent claim is infringed by making, using, selling, offering for
-sale, or importing the Program or any portion of it.
-
- 11. Patents.
-
- A "contributor" is a copyright holder who authorizes use under this
-License of the Program or a work on which the Program is based. The
-work thus licensed is called the contributor's "contributor version".
-
- A contributor's "essential patent claims" are all patent claims
-owned or controlled by the contributor, whether already acquired or
-hereafter acquired, that would be infringed by some manner, permitted
-by this License, of making, using, or selling its contributor version,
-but do not include claims that would be infringed only as a
-consequence of further modification of the contributor version. For
-purposes of this definition, "control" includes the right to grant
-patent sublicenses in a manner consistent with the requirements of
-this License.
-
- Each contributor grants you a non-exclusive, worldwide, royalty-free
-patent license under the contributor's essential patent claims, to
-make, use, sell, offer for sale, import and otherwise run, modify and
-propagate the contents of its contributor version.
-
- In the following three paragraphs, a "patent license" is any express
-agreement or commitment, however denominated, not to enforce a patent
-(such as an express permission to practice a patent or covenant not to
-sue for patent infringement). To "grant" such a patent license to a
-party means to make such an agreement or commitment not to enforce a
-patent against the party.
-
- If you convey a covered work, knowingly relying on a patent license,
-and the Corresponding Source of the work is not available for anyone
-to copy, free of charge and under the terms of this License, through a
-publicly available network server or other readily accessible means,
-then you must either (1) cause the Corresponding Source to be so
-available, or (2) arrange to deprive yourself of the benefit of the
-patent license for this particular work, or (3) arrange, in a manner
-consistent with the requirements of this License, to extend the patent
-license to downstream recipients. "Knowingly relying" means you have
-actual knowledge that, but for the patent license, your conveying the
-covered work in a country, or your recipient's use of the covered work
-in a country, would infringe one or more identifiable patents in that
-country that you have reason to believe are valid.
-
- If, pursuant to or in connection with a single transaction or
-arrangement, you convey, or propagate by procuring conveyance of, a
-covered work, and grant a patent license to some of the parties
-receiving the covered work authorizing them to use, propagate, modify
-or convey a specific copy of the covered work, then the patent license
-you grant is automatically extended to all recipients of the covered
-work and works based on it.
-
- A patent license is "discriminatory" if it does not include within
-the scope of its coverage, prohibits the exercise of, or is
-conditioned on the non-exercise of one or more of the rights that are
-specifically granted under this License. You may not convey a covered
-work if you are a party to an arrangement with a third party that is
-in the business of distributing software, under which you make payment
-to the third party based on the extent of your activity of conveying
-the work, and under which the third party grants, to any of the
-parties who would receive the covered work from you, a discriminatory
-patent license (a) in connection with copies of the covered work
-conveyed by you (or copies made from those copies), or (b) primarily
-for and in connection with specific products or compilations that
-contain the covered work, unless you entered into that arrangement,
-or that patent license was granted, prior to 28 March 2007.
-
- Nothing in this License shall be construed as excluding or limiting
-any implied license or other defenses to infringement that may
-otherwise be available to you under applicable patent law.
-
- 12. No Surrender of Others' Freedom.
-
- If conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License. If you cannot convey a
-covered work so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you may
-not convey it at all. For example, if you agree to terms that obligate you
-to collect a royalty for further conveying from those to whom you convey
-the Program, the only way you could satisfy both those terms and this
-License would be to refrain entirely from conveying the Program.
-
- 13. Use with the GNU Affero General Public License.
-
- Notwithstanding any other provision of this License, you have
-permission to link or combine any covered work with a work licensed
-under version 3 of the GNU Affero General Public License into a single
-combined work, and to convey the resulting work. The terms of this
-License will continue to apply to the part which is the covered work,
-but the special requirements of the GNU Affero General Public License,
-section 13, concerning interaction through a network will apply to the
-combination as such.
-
- 14. Revised Versions of this License.
-
- The Free Software Foundation may publish revised and/or new versions of
-the GNU General Public License from time to time. Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
- Each version is given a distinguishing version number. If the
-Program specifies that a certain numbered version of the GNU General
-Public License "or any later version" applies to it, you have the
-option of following the terms and conditions either of that numbered
-version or of any later version published by the Free Software
-Foundation. If the Program does not specify a version number of the
-GNU General Public License, you may choose any version ever published
-by the Free Software Foundation.
-
- If the Program specifies that a proxy can decide which future
-versions of the GNU General Public License can be used, that proxy's
-public statement of acceptance of a version permanently authorizes you
-to choose that version for the Program.
-
- Later license versions may give you additional or different
-permissions. However, no additional obligations are imposed on any
-author or copyright holder as a result of your choosing to follow a
-later version.
-
- 15. Disclaimer of Warranty.
-
- THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
-APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
-HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
-OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
-THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
-IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
-ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
- 16. Limitation of Liability.
-
- IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
-THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
-GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
-USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
-DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
-PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
-EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGES.
-
- 17. Interpretation of Sections 15 and 16.
-
- If the disclaimer of warranty and limitation of liability provided
-above cannot be given local legal effect according to their terms,
-reviewing courts shall apply local law that most closely approximates
-an absolute waiver of all civil liability in connection with the
-Program, unless a warranty or assumption of liability accompanies a
-copy of the Program in return for a fee.
-
- END OF TERMS AND CONDITIONS
-
- How to Apply These Terms to Your New Programs
-
- If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
- To do so, attach the following notices to the program. It is safest
-to attach them to the start of each source file to most effectively
-state the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
- {one line to give the program's name and a brief idea of what it does.}
- Copyright (C) {year} {name of author}
-
- This program is free software: you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation, either version 3 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program. If not, see <http://www.gnu.org/licenses/>.
-
-Also add information on how to contact you by electronic and paper mail.
-
- If the program does terminal interaction, make it output a short
-notice like this when it starts in an interactive mode:
-
- {project} Copyright (C) {year} {fullname}
- This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
- This is free software, and you are welcome to redistribute it
- under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License. Of course, your program's commands
-might be different; for a GUI interface, you would use an "about box".
-
- You should also get your employer (if you work as a programmer) or school,
-if any, to sign a "copyright disclaimer" for the program, if necessary.
-For more information on this, and how to apply and follow the GNU GPL, see
-<http://www.gnu.org/licenses/>.
-
- The GNU General Public License does not permit incorporating your program
-into proprietary programs. If your program is a subroutine library, you
-may consider it more useful to permit linking proprietary applications with
-the library. If this is what you want to do, use the GNU Lesser General
-Public License instead of this License. But first, please read
-<http://www.gnu.org/philosophy/why-not-lgpl.html>.
diff --git a/pycmake/PythonPackage.cmake b/pycmake/PythonPackage.cmake
deleted file mode 100644
index e6d43c3..0000000
--- a/pycmake/PythonPackage.cmake
+++ /dev/null
@@ -1,817 +0,0 @@
-# Copyright (C) 2016 Statoil ASA, Norway.
-#
-# pymake is free software: you can redistribute it and/or modify it under the
-# terms of the GNU General Public License as published by the Free Software
-# Foundation, either version 3 of the License, or (at your option) any later
-# version.
-#
-# pymake is distributed in the hope that it will be useful, but WITHOUT ANY
-# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-# A PARTICULAR PURPOSE.
-#
-# See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
-# for more details
-
-# This module exports the following functions:
-# * python_library(<target> [REQUIRE_LIBS] [EXACT] [VERSION <ver>]
-# Create a new interface library <target> that works well with
-# target_link_libraries. If the python interpreter and/or libraries are not
-# found before this function is called, it will find and configure them for you.
-#
-# When the REQUIRE_LIBS option is used, this function will fail if the python
-# libraries cannot be found. Otherwise the libraries are considered optional.
-#
-# When EXACT is specified and VERSION is not used, this option is ignored.
-# When exact is used with a version string, this function will fail in case a
-# different python version than <ver> is found. Python the X.Y and X.Y.Z
-# formats are supported.
-#
-# When VERSION <ver> is used (without exact), this specifies the minimum
-# python version.
-#
-# This function requires cmake3
-#
-# * add_python_package(<target> <name>
-# [APPEND] [VERSION__INIT__]
-# [TARGET_COPYONLY] [NO_LINK_FLAGS]
-# [SUBDIR <dir>] [PATH <path>]
-# [VERSION <version>]
-# [TARGETS <tgt>...] [SOURCES <src>...]
-# [DEPEND_DIRS <tgt1> <dir1> [<tgt2> <dir2>]...]
-# Create a new target <target>, analogous to add_library. Creates a python
-# package <name>, optionally at the path specified with PATH. If SUBDIR <dir>
-# is used, then the files will be copied to $root/dir/*, in order to create
-# python sub namespaces - if subdir is not used then all files will be put in
-# $root/*. SOURCES <src> is the python files to be copied to the directory in
-# question, and <tgt> are regular cmake libraries (targets created by
-# add_library).
-#
-# When the APPEND option is used, the files and targets given will be added
-# onto the same target package - it is necessary to use APPEND when you want
-# sub modules. Consider the package foo, with the sub module bar. In python,
-# you'd do: `from foo.bar import baz`. This means the directory structure is
-# `foo/bar/baz.py` in the package. This is accomplished with:
-# add_python_package(mypackage mypackage SOURCES __init__.py)
-# add_python_package(mypackage mypackage APPEND SOURCES baz.py)
-#
-# When VERSION__INIT__ is used, the pycmake will inject __version__ = '$ver'
-# in the __init__.py file. This version is read from PROJECT_VERSION unless
-# VERSION argument is used. If VERSION is used, this version is used instead.
-# If neither PROJECT_VERSION or VERSION is used, the string "0.0.0" is used
-# as a fallback. The same version number will be used for the add_setup_py
-# pip package.
-#
-# Without TARGET_COPYONLY, add_python_package will by default assume that the
-# targets are python extension added in the same CMakeLists.txt file that
-# invokes the function, and will modify some output properties of the targets
-# accordingly. Some python modules are meant to be used with raw dlopen and
-# only copied as-is into the python directory, and this option is intended
-# for such packages. TARGET_COPYONLY implies NO_LINK_FLAGS
-#
-# NO_LINK_FLAGS stops add_python_package from adding linker flags such as
-# export-dynamic, which is often expected by python extensions to keep them
-# independent of a very specific interpreter+library version.
-#
-# DEPEND_DIRS is needed by add_setup_py if sources for the target is set with
-# relative paths. These paths can be set later in order to be less intrusive
-# on non-python aspects of the cmake file. Still, this information is
-# necessary to accurately find and move source files to the build directory,
-# so that setup.py can find them, and might need to be added later.
-#
-# To override the version number used for this package, pass the VERSION
-# argument with a complete string. If this option is not used and
-# PROJECT_VERSION is set (CMake 3.x+), PROJECT_VERSION is used.
-#
-# This command provides install targets, but no exports.
-#
-# * add_setup_py(<target> <template>
-# [MANIFEST <manifest>]
-# [OUTPUT <output>])
-#
-# Create a setuptools package that is capable of building (for sdist+bdist)
-# and uploading packages to pypi and similar.
-#
-# The target *must* be a target created by add_python_package. The template
-# is any setup.py that works with cmake's configure_file.
-#
-# A manifest will be created and project-provided header files will be
-# included, suitable for source distribution. If you want to include other
-# things in the package that isn't suitable to add to the setup.py template,
-# point the MANIFEST argument to your base file.
-#
-# This command outputs setup.py by default, but if OUTPUT is specified, the
-# generated file is <output> instead
-#
-# * add_python_test(testname python_test_file)
-# which sets up a test target (using pycmake_test_runner.py, distributed
-# with this module) and registeres it with ctest.
-#
-# * add_python_example(package example testname test_file [args...])
-# which sets up an example program which will be run with the arguments
-# [args...] (can be empty) Useful to make sure some program runs
-# correctly with the given arguments, and which will report as a unit
-# test failure.
-
-include(CMakeParseArguments)
-
-function(pycmake_to_path_list var path1)
- if("${CMAKE_HOST_SYSTEM}" MATCHES ".*Windows.*")
- set(sep "\\;")
- else()
- set(sep ":")
- endif()
- set(result "${path1}") # First element doesn't require separator at all...
- foreach(path ${ARGN})
- set(result "${result}${sep}${path}") # .. but other elements do.
- endforeach()
- set(${var} "${result}" PARENT_SCOPE)
-endfunction()
-
-function(pycmake_init)
- if (NOT PYTHON_EXECUTABLE OR NOT PYTHON_VERSION_STRING)
- find_package(PythonInterp REQUIRED)
-
- set(PYTHON_VERSION_MAJOR ${PYTHON_VERSION_MAJOR} CACHE INTERNAL "")
- set(PYTHON_VERSION_MINOR ${PYTHON_VERSION_MINOR} CACHE INTERNAL "")
- set(PYTHON_VERSION_STRING ${PYTHON_VERSION_STRING} CACHE INTERNAL "")
- set(PYTHON_EXECUTABLE ${PYTHON_EXECUTABLE} CACHE INTERNAL "")
- endif ()
-
- set(pyver ${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR})
-
- if (EXISTS "/etc/debian_version")
- set(PYTHON_PACKAGE_PATH "dist-packages")
- else()
- set(PYTHON_PACKAGE_PATH "site-packages")
- endif()
-
- set(PYTHON_INSTALL_PREFIX "lib/python${pyver}/${PYTHON_PACKAGE_PATH}"
- CACHE STRING "Subdirectory to install Python modules in")
-endfunction()
-
-function(pycmake_list_concat out)
- foreach (arg ${ARGN})
- list(APPEND l ${arg})
- endforeach ()
-
- set(${out} ${l} PARENT_SCOPE)
-endfunction ()
-
-function(pycmake_is_system_path out path)
- string(FIND ${path} ${CMAKE_SOURCE_DIR} ${out})
-
- if (${out} EQUAL -1)
- set(${out} TRUE PARENT_SCOPE)
- else ()
- set(${out} FALSE PARENT_SCOPE)
- endif ()
-endfunction ()
-
-# internal. Traverse the tree of dependencies (linked targets) that are actual
-# cmake targets and add to a list
-function(pycmake_target_dependencies dependencies links target)
- get_target_property(deps ${target} INTERFACE_LINK_LIBRARIES)
-
- if (NOT deps)
- get_target_property(deps ${target} LINK_LIBRARIES)
- endif ()
-
- # LINK_LIBRARIES could be not-found, in which we make it an empty list
- if (NOT deps)
- set(deps "")
- endif ()
-
- set(_links "")
- list(APPEND _dependencies ${target})
- foreach (dep ${deps})
- if (TARGET ${dep})
- pycmake_target_dependencies(trans_tgt trans_link ${dep})
- foreach (link ${trans_tgt})
- list(APPEND _dependencies ${link})
- endforeach ()
- pycmake_list_concat(_links ${_links} ${trans_link})
- else ()
- list(APPEND _links ${dep})
- endif ()
- endforeach ()
-
- if ( _dependencies )
- list(REMOVE_DUPLICATES _dependencies)
- endif ()
- if (_links)
- list(REMOVE_DUPLICATES _links)
- endif ()
- set(${dependencies} "${_dependencies}" PARENT_SCOPE)
- set(${links} "${_links}" PARENT_SCOPE)
-endfunction ()
-
-# internal. Traverse the set of dependencies (linked targets) to some parent
-# and create a list of its source files, preprocessor definitions, include
-# directories and custom compiler options, and write these as properties on the
-# the target.
-#
-# In effect, these properties are set on the python package target (created
-# with add_python_package):
-#
-# PYCMAKE_EXTENSIONS - a list of extensions (C/C++ targets) for the package
-# For each extension in this list, these variables are set on the package:
-# PYCMAKE_<ext>_INCLUDE_DIRECTORIES
-# PYCMAKE_<ext>_SOURCES
-# PYCMAKE_<ext>_COMPILE_DEFINITIONS
-# PYCMAKE_<ext>_COMPILE_OPTIONS
-# PYCMAKE_<ext>_LINK_LIBRARIES
-#
-# All properties are lists, and the content correspond to the non-namespaced
-# properties (includes, sources etc.)
-function(pycmake_include_target_deps pkg tgt depend_dirs)
- pycmake_target_dependencies(deps links ${tgt})
- set(includes "")
- set(defines "")
- set(sources "")
- set(flags "")
- if (NOT links)
- set(links "")
- endif ()
-
- foreach (dep ${deps})
- # If this is an interface library then most of these are probably empty
- # *and* cmake will crash if we look up any non-INTERFACE_ properties,
- # so prepend INTERFACE_ on interface targets
- unset(INTERFACE_)
- get_target_property(type ${dep} TYPE)
- if (type STREQUAL INTERFACE_LIBRARY)
- set(INTERFACE_ INTERFACE_)
- endif ()
-
- get_target_property(incdir ${dep} ${INTERFACE_}INCLUDE_DIRECTORIES)
- get_target_property(srcs ${dep} ${INTERFACE_}SOURCES)
- get_target_property(defs ${dep} ${INTERFACE_}COMPILE_DEFINITIONS)
- get_target_property(flgs ${dep} ${INTERFACE_}COMPILE_OPTIONS)
-
- # prune -NOTFOUND props
- foreach (var incdir srcs defs flgs)
- if(NOT ${var})
- set(${var} "")
- endif ()
- endforeach ()
-
- # If sources files were registered with absolute path (prefix'd with
- # ${CMAKE_SOURCE_DIR}) we can just use this absolute path and
- # be fine. If not, we assume that if the source file is *not* relative
- # but below the current dir if it's NOT in the depend_dir list, in
- # which case we make it absolute. This ends up in the sources argument
- # to Extensions in setup.py
- list(FIND depend_dirs ${dep} index)
- if (NOT ${index} EQUAL -1)
- math(EXPR index "${index} + 1")
- list(GET depend_dirs ${index} prefix)
- else ()
- set(prefix ${CMAKE_CURRENT_SOURCE_DIR})
- endif ()
-
- unset(_srcs)
- foreach (src ${srcs})
- string(FIND ${src} ${CMAKE_SOURCE_DIR} x)
- if(${x} EQUAL 0)
- list(APPEND _srcs ${src})
- else()
- list(APPEND _srcs ${prefix}/${src})
- endif()
- endforeach ()
- unset(prefix)
-
- list(APPEND includes ${incdir})
- list(APPEND sources ${_srcs})
- list(APPEND defines ${defs})
- list(APPEND flags ${flgs})
- endforeach()
-
- get_target_property(extensions ${pkg} PYCMAKE_EXTENSIONS)
- list(APPEND extensions ${tgt})
-
- # properties may contain generator expressions, which we filter out
-
- string(REGEX REPLACE "\\$<[^>]+>;?" "" includes "${includes}")
- string(REGEX REPLACE "\\$<[^>]+>;?" "" sources "${sources}")
- string(REGEX REPLACE "\\$<[^>]+>;?" "" defines "${defines}")
- string(REGEX REPLACE "\\$<[^>]+>;?" "" flags "${flags}")
-
- # sources (on shared windows build) can contain .def files for exporting
- # symbols. These are filtered out too, as exporting non-python symbols is
- # uninteresting from a pip setting.
- string(REGEX REPLACE "[^;]*[.]def;?" "" sources "${sources}")
-
- set_target_properties(${pkg} PROPERTIES
- PYCMAKE_EXTENSIONS "${extensions}"
- PYCMAKE_${tgt}_INCLUDE_DIRECTORIES "${includes}"
- PYCMAKE_${tgt}_SOURCES "${sources}"
- PYCMAKE_${tgt}_LINK_LIBRARIES "${links}"
- PYCMAKE_${tgt}_COMPILE_DEFINITIONS "${defines}"
- PYCMAKE_${tgt}_COMPILE_OPTIONS "${flags}")
-endfunction()
-
-function(python_library target)
- pycmake_init()
-
- set(options EXACT REQUIRE_LIBS)
- set(unary VERSION)
- set(nary)
- cmake_parse_arguments(PP "${options}" "${unary}" "${nary}" "${ARGN}")
-
- if (PP_VERSION)
- string(REGEX MATCH "[0-9][.][0-9]+" xy "${PP_VERSION}")
- if (NOT xy)
- set(problem "Unexpected format for VERSION argument")
- set(solution "Was ${PP_VERSION}, expected X.Y (e.g. 3.5)")
- message(SEND_ERROR "${problem}. ${solution}")
- endif ()
- endif ()
-
- if (PP_EXACT AND NOT PP_VERSION)
- unset(PP_EXACT)
- endif ()
-
- set(xyver ${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR})
- if (PP_EXACT AND ("${PYTHON_VERSION_STRING}" VERSION_EQUAL "${PP_VERSION}"
- OR ${xyver} VERSION_EQUAL "${PP_VERSION}"))
- set(problem "Wrong Python version")
- set(solution "${PP_VERSION} requested, got ${PYTHON_VERSION_STRING}")
- message(SEND_ERROR "${problem}: ${solution}.")
- endif ()
-
- if (PP_VERSION AND "${PYTHON_VERSION_STRING}" VERSION_LESS "${PP_VERSION}")
- set(found "Found Python ${PYTHON_VERSION_STRING}")
- set(requested "Python >= ${PP_VERSION} requested")
- message(SEND_ERROR "${found}, but ${requested}.")
- endif ()
-
- add_library(${target} INTERFACE)
-
- if (PP_REQUIRE_LIBS)
- set(req REQUIRED)
- endif ()
-
- if (NOT PYTHONLIBS_FOUND)
- find_package(PythonLibs ${req})
-
- if (NOT PYTHONLIBS_FOUND)
- return ()
- endif ()
-
- set(PYTHONLIBS_FOUND ${PYTHONLIBS_FOUND} CACHE INTERNAL "")
- set(PYTHON_LIBRARIES ${PYTHON_LIBRARIES} CACHE INTERNAL "")
- set(PYTHON_INCLUDE_DIRS ${PYTHON_INCLUDE_DIRS} CACHE INTERNAL "")
- endif ()
-
- target_link_libraries(${target} INTERFACE ${PYTHON_LIBRARIES})
- target_include_directories(${target} SYSTEM INTERFACE ${PYTHON_INCLUDE_DIRS})
-endfunction()
-
-function(add_python_package pkg NAME)
- set(options APPEND VERSION__INIT__ TARGET_COPYONLY NO_LINK_FLAGS)
- set(unary PATH SUBDIR VERSION)
- set(nary TARGETS SOURCES DEPEND_DIRS)
- cmake_parse_arguments(PP "${options}" "${unary}" "${nary}" "${ARGN}")
-
- if (TARGET_COPYONLY)
- set(PP_NO_LINK_FLAGS TRUE)
- endif ()
-
- pycmake_init()
- set(installpath ${CMAKE_INSTALL_PREFIX}/${PYTHON_INSTALL_PREFIX})
-
- if (PP_PATH)
- # obey an optional path to install into - but prefer the reasonable
- # default of currentdir/name
- set(dstpath ${PP_PATH})
- else ()
- set(dstpath ${NAME})
- endif()
-
- # if APPEND is passed, we *add* files/directories instead of creating it.
- # this can be used to add sub directories to a package. If append is passed
- # and the target does not exist - create it
- if (TARGET ${pkg} AND NOT PP_APPEND)
- set(problem "Target '${pkg}' already exists")
- set(descr "To add more files to this package")
- set(solution "${descr}, use add_python_package(<target> <name> APPEND)")
- message(SEND_ERROR "${problem}. ${solution}.")
-
- elseif (NOT TARGET ${pkg})
- add_custom_target(${pkg} ALL)
-
- get_filename_component(abspath ${CMAKE_CURRENT_BINARY_DIR} ABSOLUTE)
- set_target_properties(${pkg} PROPERTIES PACKAGE_INSTALL_PATH ${installpath})
- set_target_properties(${pkg} PROPERTIES PACKAGE_BUILD_PATH ${abspath})
- set_target_properties(${pkg} PROPERTIES PYCMAKE_PACKAGE_NAME ${NAME})
- set_target_properties(${pkg} PROPERTIES PYCMAKE_PACKAGES ${NAME})
-
- set(pkgver "0.0.0")
- if (PROJECT_VERSION)
- set(pkgver ${PROJECT_VERSION})
- endif ()
-
- if (PP_VERSION)
- set(pkgver ${PP_VERSION})
- endif ()
-
- set_target_properties(${pkg} PROPERTIES PYCMAKE_PACKAGE_VERSION ${pkgver})
-
- # set other properties we might populate later
- set_target_properties(${pkg} PROPERTIES PYCMAKE_EXTENSIONS "")
-
- endif ()
- # append subdir if requested
- if (PP_SUBDIR)
- set(dstpath ${dstpath}/${PP_SUBDIR})
-
- # save modules added with SUBDIR - setup.py will want them in packages
- get_target_property(_packages ${pkg} PYCMAKE_PACKAGES)
- get_target_property(_pkgname ${pkg} PYCMAKE_PACKAGE_NAME)
- list(APPEND _packages ${_pkgname}/${PP_SUBDIR})
- set_target_properties(${pkg} PROPERTIES PYCMAKE_PACKAGES "${_packages}")
- unset(_packages)
- unset(_pkgname)
- endif ()
-
- # this is pretty gritty, but cmake has no generate-time file append write a
- # tiny cmake script that appends to some file and writes the version
- # string, which hooks into add_custom_command, and append this command on
- # the copy of the __init__ requested for versioning. This means writing
- # __version__ is a part of the file copy itself and won't be considered a
- # change to the file.
- if (PP_VERSION__INIT__)
- if (PP_SUBDIR)
- set(f ${PP_SUBDIR})
- else ()
- set(f init)
- endif ()
- string(REGEX REPLACE "[:/\\]" "-" initscript "${pkg}.${f}.cmake")
- unset(f)
- set(initscript ${CMAKE_CURRENT_BINARY_DIR}/${initscript})
-
- message(STATUS "Writing to " ${initscript})
- file(WRITE ${initscript}
- "file(APPEND \${PYCMAKE__INIT__} __version__='${pkgver}')"
- )
- endif ()
-
- # copy all .py files into
- foreach (file ${PP_SOURCES})
-
- get_filename_component(absfile ${file} ABSOLUTE)
- get_filename_component(fname ${file} NAME)
-
- file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/${dstpath})
- add_custom_command(OUTPUT ${dstpath}/${fname}
- COMMAND ${CMAKE_COMMAND} -E copy ${absfile} ${dstpath}/
- DEPENDS ${absfile}
- )
-
- list(APPEND _files ${CMAKE_CURRENT_BINARY_DIR}/${dstpath}/${fname})
-
- if ("${fname}" STREQUAL "__init__.py" AND PP_VERSION__INIT__)
- message(STATUS "Writing __version__ ${pkgver} to package ${pkg}.")
- add_custom_command(OUTPUT ${dstpath}/${fname}
- COMMAND ${CMAKE_COMMAND} -DPYCMAKE__INIT__=${dstpath}/${fname}
- -P ${initscript}
- APPEND
- )
- unset(initpy)
- unset(initscript)
- endif ()
- endforeach ()
-
- # drive the copying of .py files and add the dependency on the python
- # package target
- get_target_property(_pkgname ${pkg} PYCMAKE_PACKAGE_NAME)
- set(_id ${pkg}-${_pkgname})
- string(REGEX REPLACE "[:/\\]" "-" _subdir "${PP_SUBDIR}-${_pkgname}")
-
- # make target-names slightly nicer, i.e. use subdir as target names
- if (NOT TARGET ${pkg}-${_subdir} AND PP_SUBDIR)
- set(pycmake-${pkg}-${_subdir} 0 CACHE INTERNAL "")
- set(_id ${pkg}-${_subdir})
- elseif (PP_SUBDIR)
- # The same SUBDIR has been used multiple times for this target Since
- # it's not possible to append source files to custom targets, a new one
- # is created with an enumerator, incremented for every extra use.
- math(EXPR _id "${pycmake-${pkg}-${_subdir}} + 1")
- set(pycmake-${pkg}-${_subdir} ${_id} CACHE INTERNAL "" FORCE)
- set(_id ${pkg}-${_subdir}-${_id})
- endif ()
-
- add_custom_target(${_id} ALL SOURCES ${_files} DEPENDS ${_files})
- add_dependencies(${pkg} ${_id})
- unset(_id)
- unset(_subdir)
-
- # targets are compiled as regular C/C++ libraries (via add_library), before
- # we add some python specific stuff for the linker here.
- set(SUFFIX ".so")
- if (WIN32 OR CYGWIN)
- # on windows, .pyd is used as extension instead of DLL
- set(SUFFIX ".pyd")
- elseif (APPLE)
- # the spaces in LINK_FLAGS are important; otherwise APPEND_STRING to
- # set_property seem to combine it with previously-set options or
- # mangles it in some other way
- set(LINK_FLAGS " -undefined dynamic_lookup ")
- else()
- set(LINK_FLAGS " -Xlinker -export-dynamic ")
- endif()
-
- # register all targets as python extensions
- foreach (tgt ${PP_TARGETS})
- if (LINK_FLAGS AND NOT PP_NO_LINK_FLAGS)
- set_property(TARGET ${tgt} APPEND_STRING PROPERTY LINK_FLAGS ${LINK_FLAGS})
- endif()
-
- if (PP_TARGET_COPYONLY)
- # ecl and other libraries relies on ctypes and dlopen. We want to
- # copy a proper install'd target when we invoke make install, in
- # particular because cmake then handles rpath stripping properly,
- # so we do a dummy install into our build directory and then
- # immediately install that. This does not modify the target in any
- # way and does not require it to be in the same directory.
- #
- # for the build tree, the library is simply copied
-
- # copy all targets into the package directory
- get_target_property(_lib ${tgt} OUTPUT_NAME)
- if (NOT _lib)
- # if OUTPUT_NAME is not set, library base name is the same as the
- # target name
- set(_lib ${tgt})
- endif ()
-
- string(REGEX REPLACE "^lib" "" _lib ${_lib}${SUFFIX})
- file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/${dstpath})
-
- add_custom_command(OUTPUT ${dstpath}/${_lib}
- COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:${tgt}> ${dstpath}/${_lib}
- DEPENDS ${tgt}
- )
-
- # Install the shared library as-is. Note that cmake typically
- # strips build-time rpath on install, but this object is in fact
- # never installed, so it possibly keeps rpaths to the build directory
- install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${dstpath}/${_lib}
- DESTINATION ${installpath}/${dstpath}
- )
-
- add_custom_target(pycmake-ext-${pkg}-${_lib} ALL DEPENDS ${dstpath}/${_lib})
- add_dependencies(${pkg} pycmake-ext-${pkg}-${_lib})
- unset(_lib)
- endif()
-
- # traverse all dependencies and get their include dirs, link flags etc.
- pycmake_include_target_deps(${pkg} ${tgt} "${PP_DEPEND_DIRS}")
-
- endforeach ()
-
- if (NOT PP_TARGET_COPYONLY AND PP_TARGETS)
- install(TARGETS ${PP_TARGETS}
- LIBRARY DESTINATION ${installpath}/${dstpath}
- )
-
- # proper python extensions - they're assumed to be created in the
- # same dir as add_python_package is invoked and directly modify the
- # target by changing output dir and setting suffix.
- #
- # The python package does not distinguish between debug/release
- # builds, but this usually only matters for Windows.
- #
- # LIBRARY_OUTPUT_DIRECTORY only works with cmake3.0 - to support cmake
- # 2.8.12, also copy the file.
- set_target_properties(${PP_TARGETS} PROPERTIES
- LIBRARY_OUTPUT_DIRECTORY ${dstpath}
- LIBRARY_OUTPUT_DIRECTORY_DEBUG ${dstpath}
- LIBRARY_OUTPUT_DIRECTORY_RELEASE ${dstpath}
- RUNTIME_OUTPUT_DIRECTORY ${dstpath}
- RUNTIME_OUTPUT_DIRECTORY_DEBUG ${dstpath}
- RUNTIME_OUTPUT_DIRECTORY_RELEASE ${dstpath}
- PREFIX ""
- SUFFIX "${SUFFIX}"
- )
-
- if (${CMAKE_VERSION} VERSION_LESS 3.0)
- foreach(tgt ${PP_TARGETS})
- add_custom_command(TARGET ${tgt}
- COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:${tgt}> ${dstpath}/
- )
- endforeach()
- endif ()
- endif ()
-
- if (_files)
- install(FILES ${_files} DESTINATION ${installpath}/${dstpath})
- unset(_files)
- endif ()
-
- if (NOT PP_SOURCES AND NOT PP_TARGETS AND NOT PP_APPEND)
- message(SEND_ERROR
- "add_python_package called without .py files or C/C++ targets.")
- endif()
-endfunction()
-
-function(add_setup_py target template)
- set(options)
- set(unary MANIFEST OUTPUT)
- set(nary)
- cmake_parse_arguments(PP "${options}" "${unary}" "${nary}" "${ARGN}")
-
- string(TOUPPER "${CMAKE_BUILD_TYPE}" buildtype)
-
- get_target_property(PYCMAKE_PACKAGE_NAME ${target} PYCMAKE_PACKAGE_NAME)
- get_target_property(PYCMAKE_VERSION ${target} PYCMAKE_PACKAGE_VERSION)
- get_target_property(extensions ${target} PYCMAKE_EXTENSIONS)
- get_target_property(pkg ${target} PYCMAKE_PACKAGES)
-
- get_directory_property(dir_inc INCLUDE_DIRECTORIES)
- get_directory_property(dir_def COMPILE_DEFINITIONS)
- get_directory_property(dir_opt COMPILE_OPTIONS)
- string(REGEX REPLACE " " ";" dir_opt "${dir_opt}")
-
- set(cflags ${CMAKE_C_FLAGS})
- set(cxxflags ${CMAKE_CXX_FLAGS})
- if (buildtype)
- set(cflags ${cflags} ${CMAKE_C_FLAGS_${buildtype}})
- set(cxxflags ${cxxflags} ${CMAKE_CXX_FLAGS_${buildtype}})
- endif ()
-
- string(REGEX REPLACE " " ";" cflags "${cflags}")
- string(REGEX REPLACE " " ";" cxxflags "${cxxflags}")
- set(flags ${cflags} ${cxxflags})
-
- foreach (item ${pkg})
- string(REGEX REPLACE "/" "." item ${item})
- list(APPEND _pkg "'${item}'")
- endforeach()
- string(REGEX REPLACE ";" "," pkg "${_pkg}")
- set(PYCMAKE_PACKAGES "${pkg}")
-
- foreach (ext ${extensions})
-
- get_target_property(inc ${target} PYCMAKE_${ext}_INCLUDE_DIRECTORIES)
- get_target_property(src ${target} PYCMAKE_${ext}_SOURCES)
- get_target_property(lnk ${target} PYCMAKE_${ext}_LINK_LIBRARIES)
- get_target_property(def ${target} PYCMAKE_${ext}_COMPILE_DEFINITIONS)
- get_target_property(opt ${target} PYCMAKE_${ext}_COMPILE_OPTIONS)
-
- pycmake_list_concat(inc ${dir_inc} ${inc})
- pycmake_list_concat(def ${dir_def} ${def})
- pycmake_list_concat(opt ${flags} ${dir_opt} ${opt})
-
- # remove the python include dir and lib (which is obviously unecessary)
-
- if(inc AND PYTHON_INCLUDE_DIRS)
- list(REMOVE_ITEM inc ${PYTHON_INCLUDE_DIRS})
- endif()
- if(lnk AND PYTHON_LIBRARIES)
- list(REMOVE_ITEM lnk ${PYTHON_LIBRARIES})
- endif()
-
- # wrap every string in single quotes (because python expects this)
- foreach (item ${inc})
- # project-provided headers must be bundled for sdist, so add them
- # to the pycmake/include directory
- get_filename_component(dstpath pycmake/include/${item} DIRECTORY)
- string(REGEX REPLACE "${CMAKE_SOURCE_DIR}" "" dstpath "${dstpath}")
- string(REGEX REPLACE "${CMAKE_BINARY_DIR}" "" dstpath "${dstpath}")
- string(REGEX REPLACE "//" "/" dstpath "${dstpath}")
-
- pycmake_is_system_path(syspath ${item})
- if (NOT ${syspath})
- file(COPY ${item} DESTINATION ${dstpath})
- endif ()
- get_filename_component(item ${item} NAME)
- list(APPEND _inc "'${dstpath}/${item}'")
- unset(dstpath)
- endforeach ()
-
- foreach (item ${src})
- # setup.py is pretty grumpy and wants source files relative itself
- # AND not upwards, so we must copy our entire source tree into the
- # build dir
- string(REGEX REPLACE "${CMAKE_SOURCE_DIR}" "" dstitem "pycmake/src/${item}")
- string(REGEX REPLACE "${CMAKE_BINARY_DIR}" "" dstitem "${dstitem}")
- string(REGEX REPLACE "//" "/" dstitem "${dstitem}")
- configure_file(${item} ${CMAKE_CURRENT_BINARY_DIR}/${dstitem} COPYONLY)
- list(APPEND _src "'${dstitem}'")
- unset(dstitem)
- endforeach ()
-
- foreach (item ${opt})
- list(APPEND _opt "'${item}'")
- endforeach ()
-
- set(_lnk "")
- foreach (item ${lnk})
- get_filename_component(_libdir ${item} DIRECTORY)
-
- if (_libdir)
- list(APPEND _dir '${_libdir}')
- get_filename_component(item ${item} NAME_WE)
- string(REGEX REPLACE "lib" "" item ${item})
- endif ()
-
- list(APPEND _lnk "'${item}'")
- endforeach ()
-
- # defines are a bit more work, because setup.py expects them as tuples
- foreach (item ${def})
- string(FIND ${item} "=" pos)
-
- set(_val None)
- string(SUBSTRING "${item}" 0 ${pos} _name)
-
- if (NOT ${pos} EQUAL -1)
- math(EXPR pos "${pos} + 1")
- string(SUBSTRING "${item}" ${pos} -1 _val)
- set(_val '${_val}')
- endif ()
-
- list(APPEND _def "('${_name}', ${_val})")
- endforeach ()
-
- if (_inc)
- list(REMOVE_DUPLICATES _inc)
- endif ()
- if( _src)
- list(REMOVE_DUPLICATES _src)
- endif ()
- if( _def)
- list(REMOVE_DUPLICATES _def)
- endif ()
- if( _lnk)
- list(REMOVE_DUPLICATES _lnk)
- endif ()
- # do not remote duplictes for compiler options, because some are
- # legitemately passed multiple times, e.g. on clang for osx builds
- # `-arch i386 -arch x86_64`
-
- # then make the list comma-separated (for python)
- string(REGEX REPLACE ";" "," inc "${_inc}")
- string(REGEX REPLACE ";" "," src "${_src}")
- string(REGEX REPLACE ";" "," def "${_def}")
- string(REGEX REPLACE ";" "," opt "${_opt}")
- string(REGEX REPLACE ";" "," lnk "${_lnk}")
- string(REGEX REPLACE ";" "," dir "${_dir}")
-
- # TODO: be able to set other name than ext
- list(APPEND setup_extensions "Extension('${PYCMAKE_PACKAGE_NAME}.${ext}',
- sources=[${src}],
- include_dirs=[${inc}],
- define_macros=[${def}],
- library_dirs=[${dir}],
- libraries=[${lnk}],
- extra_compile_args=[${opt}])")
-
- endforeach()
-
- string(REGEX REPLACE ";" "," PYCMAKE_EXTENSIONS "${setup_extensions}")
-
- # When extensions are built, headers aren't typically included for source
- # dists, which are instead read from a manifest file. If a base is provided
- # we copy that, then append. If no template is provided, overwrite so it's
- # clean every time we append
- if (PP_MANIFEST)
- configure_file(${PP_MANIFEST} MANIFEST.in COPYONLY)
- else ()
- file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/MANIFEST.in)
- endif ()
-
- # Make a best-effort guess finding header files, trying all common
- # extensions
- file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/MANIFEST.in
- "recursive-include pycmake/include *.h *.hh *.H *.hpp *.hxx")
-
- set(setup.py setup.py)
- if (PP_OUTPUT)
- set(setup.py ${PP_OUTPUT})
- endif ()
- configure_file(${template} ${setup.py})
-endfunction ()
-
-function(add_python_test TESTNAME PYTHON_TEST_FILE)
- configure_file(${PYTHON_TEST_FILE} ${PYTHON_TEST_FILE} COPYONLY)
- get_filename_component(name ${PYTHON_TEST_FILE} NAME)
- get_filename_component(dir ${PYTHON_TEST_FILE} DIRECTORY)
-
- add_test(NAME ${TESTNAME}
- COMMAND ${PYTHON_EXECUTABLE} -m unittest discover -vs ${dir} -p ${name}
- )
-endfunction()
-
-function(add_python_example pkg TESTNAME PYTHON_TEST_FILE)
- configure_file(${PYTHON_TEST_FILE} ${PYTHON_TEST_FILE} COPYONLY)
-
- add_test(NAME ${TESTNAME}
- WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
- COMMAND ${PYTHON_EXECUTABLE} ${PYTHON_TEST_FILE} ${ARGN})
-
- get_target_property(buildpath ${pkg} PACKAGE_BUILD_PATH)
- pycmake_to_path_list(pythonpath "$ENV{PYTHONPATH}" ${buildpath})
- set_tests_properties(${TESTNAME} PROPERTIES ENVIRONMENT "PYTHONPATH=${pythonpath}")
-endfunction()
diff --git a/pycmake/README.md b/pycmake/README.md
deleted file mode 100644
index 0c1c71c..0000000
--- a/pycmake/README.md
+++ /dev/null
@@ -1,132 +0,0 @@
-# pycmake
-
-**pycmake** is a CMake macro for testing that we have the necessary Python
-modules in the necessary versions for our systems. The basic assumption of this
-package is PEP 396 -- Module Version Numbers as layed out in
-https://www.python.org/dev/peps/pep-0396/ . Here it says that a Python module
-*should* expose a field `__version__`, that is, to obtain a module's version,
-one may run
-
- import module as m
- print(m.__version__)
-
-
-Unfortunately, not all Python modules expose a version number, like *inspect*.
-Other Python modules expose several version numbers, e.g., one for the
-underlying software and one for the python packaging, like *SQLite* and *PyQt*.
-To handle the different ways of obtaining the version, one may explicitly state
-the version *accessor* to use; `__version__` is the default.
-
-For more information on module version numbers, see
-[PEP 396](https://www.python.org/dev/peps/pep-0396/).
-
-
-
-
-## Examples
-
-The most vanilla example usage is the following, where we require *numpy*
-version at least 1.7.0, and any newer version is acceptable. Consider the
-two CMake lines, whose behavior are identical:
-
- python_module( numpy REQUIRED 1.7.0 )
- python_module( numpy REQUIRED 1.7.0 MINIMUM )
-
-
-However, sometimes we are phasing out an older Python module, in which case, we
-can give the user a warning. By writing
-
- python_module( scipy REQUIRED 1.5.1 OPTIONAL )
-
-we are telling CMake to output a warning to the user if a *scipy* version
-below 1.5.1 is found, and to exit with an error if *scipy* is not found.
-
-Yet other times, our systems do not work with newer versions than a certain
-number. By writing
-
- python_module( pandas REQUIRED 0.15.1 EXACT )
-
-we ask CMake to fail if *pandas* 0.15.1 is not installed, i.e., even if
-*pandas* 0.15.2 is installed.
-
-
-More examples:
-
- find_python_module( numpy REQUIRED 1.5.3 MINIMUM )
- find_python_module( numpy REQUIRED 1.5.3 EXACT )
- find_python_module( numpy REQUIRED 1.5.3 OPTIONAL )
- find_python_module( numpy REQUIRED 1.5.3 )
- find_python_module( numpy REQUIRED )
- find_python_module( numpy OPTIONAL )
- find_python_module( numpy REQUIRED 1.5.3 MINIMUM "__version__" )
-
-
-Not every Python module exposes `__version__`, and some module exposes several
-flags, like `version` and `apilevel`.
-
-<!--
-*SQLite2* users beware. They expose `sqlite_version_info`, `version`, and
-`version_info`. There is a difference between the SQLite version (e.g. 2
-or 3) and the *python-pysqlite* version, e.g. 1.0.1. *SQLite2*
-exposes `apilevel = '2.0'` and `version = '1.0.1'`. It is therefore possible to
-get both `apilevel` and `version`, as well as `__version__` etc.
--->
-
-
-Complex systems like SQLite and Qt exposes more than one version field. For
-instance, SQLite 2 vs *python-pysqlite1*. SQLite has version 2.0,
-whereas the Python package *python-pysqlite1* has version 1.0.1. These are
-accessible by calling
-
- apilevel = '2.0'
- version = '1.0.1'
-
-It is possible to obtain these properties by invoking `python_module` providing
-a fifth argument, the *version accessor* argument:
-
- python_module( sqlite REQUIRED 2.0 MINIMUM "apilevel" )
- python_module( sqlite REQUIRED 1.0.1 MINIMUM "version" )
- python_module( numpy REQUIRED 1.7.1 MINIMUM "__version__" )
-
-
-*PyQt4* does not export any version field. Importing *PyQt4.Qt* in Python
-reveals fields
-
- PYQT_VERSION_STR = '4.10.4'
- QT_VERSION_STR = '4.8.6'
-
-
-
-## Technicalities
-
-This repo contains two files of interest. The `CMakeLists.txt` loads the more
-interesting file `FindPythonModule.cmake`, and then provides some use cases.
-`FindPythonModule.cmake` contains two macros, one main and one auxilliary:
-
-* `macro( python_module_version module )`
-* `macro( python_module module version )` — this is the interface
-
-The first macro, `python_module_version`, checks if `module` is a Python
-importable package, and if so, which version `module` has. The version is found
-simply by the following Python program:
-
- import package as py_m
- print(py_m.__version__)
-
-
-If this program fails, the status flag will be set to `1`, and the package
-will be assumed to not exist. If the program succeeds, the output of the
-program will be stored in the global cmake variable `PY_${package}` where
-`${package}` is the name of the package given to the macro `python_module`.
-
-
-The macro, `python_module(module version)` calls the function,
-`python_module_version(module)` and checks if
-
-1. The variable `PY_${module}` has been set. If the package is `REQUIRED`, then
- the variable must have been set, otherwise we message a `SEND_ERROR`, and
- CMake will fail. If the package is `OPTIONAL` and not found, we issue a
- `WARNING`.
-1. The we compare the version number found (the content of the variable
- `PY_${module}`). The keywords `EXACT`, `MINIMUM` and `OPTIONAL` are
- self-explanatory.
diff --git a/pycmake/test/CMakeLists.txt b/pycmake/test/CMakeLists.txt
deleted file mode 100644
index 788c0ed..0000000
--- a/pycmake/test/CMakeLists.txt
+++ /dev/null
@@ -1,31 +0,0 @@
-# Test the module - assumes some packages are installed.
-
-find_package( PythonInterp 2.6 REQUIRED )
-include( ${CMAKE_SOURCE_DIR}/FindPythonModule.cmake )
-
-python_module( ctypes )
-python_module( numpy REQUIRED 1.8 )
-python_module( pandas REQUIRED 0.18.1 EXACT )
-
-python_module( matplotlib REQUIRED 1.2 MINIMUM )
-python_module( PyQt4 REQUIRED 4.8 )
-python_module( PyQt4.Qt REQUIRED 4.8 MINIMUM "QT_VERSION_STR" )
-python_module( PyQt4.Qt REQUIRED 4.10 MINIMUM "PYQT_VERSION_STR" )
-python_module( re REQUIRED 2.2.1 MINIMUM )
-python_module( requests REQUIRED 2.2.1 EXACT )
-python_module( inspect OPTIONAL )
-#python_module( pandas REQUIRED 9.9.9 OPTIONAL ) # will warn but pass
-
-python_module( cwrap QUIET )
-python_module( cwrap QUIET 1.0)
-python_module( no_such_module QUIET )
-python_module( scipy QUIET 0.16.1 )
-
-if (DEFINED PY_inspect)
- # Here we can do stuff depending on having *inspect*
- message(STATUS "We have inspect.")
-else()
- # And here we can do stuff when we do not have *inspect*
- message(STATUS "We do not have inspect, ignoring ...")
-endif()
-
diff --git a/python/CMakeLists.txt b/python/CMakeLists.txt
index 02df26e..6a9dd7d 100644
--- a/python/CMakeLists.txt
+++ b/python/CMakeLists.txt
@@ -1,93 +1,119 @@
project(segyio-python)
-if (NOT BUILD_PYTHON)
- return()
+if (REQUIRE_PYTHON)
+ set(BUILD_PYTHON ON)
endif()
-find_package(PythonInterp)
-find_package(PythonLibs)
-include(FindPythonModule)
-include(PythonPackage)
-
-if (NOT DEFINED PYTHON_EXECUTABLE)
- message("Python interpreter not found - Python wrappers not enabled")
- unset(BUILD_PYTHON)
+if (NOT BUILD_PYTHON)
return()
endif()
+find_package(PythonInterp REQUIRED)
-python_module(numpy REQUIRED 1.10)
-if (NOT DEFINED PY_numpy)
- message("numpy module not found - Python wrappers not enabled")
- unset(BUILD_PYTHON)
+if (NOT PYTHON_EXECUTABLE AND REQUIRE_PYTHON)
+ message(SEND_ERROR "Could not find python executable")
return()
endif()
-if (NOT PYTHONLIBS_FOUND)
- message("Python libraries not found.")
- unset(BUILD_PYTHON)
+if (NOT PYTHON_EXECUTABLE)
+ message(WARNING "Could not find python - skipping python bindings")
return()
endif()
-add_library(_segyio MODULE segyio/_segyio.c)
-target_link_libraries(_segyio PUBLIC segyio)
-target_include_directories(_segyio PRIVATE ${PYTHON_INCLUDE_DIRS})
-export(TARGETS _segyio segyio-shared segyio-static APPEND FILE segyio-config.cmake)
+set(python ${PYTHON_EXECUTABLE})
-if(MSVC)
- target_link_libraries(_segyio PRIVATE ${PYTHON_LIBRARIES})
-else()
- target_compile_options(_segyio PUBLIC "-std=c99")
+if (NOT WIN32)
+ # setuptools on microsoft compilers doesn't support the --library-dir flag
+ # and crashes, so only pass it on non-microsoft platforms
+ set(setup-py-libdir build_ext
+ --rpath $<TARGET_FILE_DIR:segyio-shared>
+ --library-dirs $<TARGET_FILE_DIR:segyio-shared>)
endif ()
-add_python_package(pysegyio segyio
- TARGETS _segyio
- DEPEND_DIRS segyio ${CMAKE_SOURCE_DIR}/lib
- VERSION ${segyio_VERSION}
- VERSION__INIT__
- SOURCES segyio/__init__.py
- segyio/_header.py
- segyio/_gather.py
- segyio/_line.py
- segyio/_field.py
- segyio/_trace.py
- segyio/_raw_trace.py
- segyio/segy.py
- segyio/tracefield.py
- segyio/binfield.py
- segyio/open.py
- segyio/create.py
- segyio/tools.py
- segyio/su.py
- segyio/segysampleformat.py
- segyio/tracesortingformat.py)
-
-add_setup_py(pysegyio setup.py.in)
-
-# Add license & readme to the pip distribution
-configure_file(${CMAKE_SOURCE_DIR}/License.md License)
-configure_file(${CMAKE_SOURCE_DIR}/README.md README)
-
-file(GLOB sgys "${CMAKE_SOURCE_DIR}/test-data/*.sgy")
+set(setup-py ${CMAKE_SOURCE_DIR}/setup.py)
+add_custom_target(
+ segyio-python ALL
+ COMMENT "Building python library with setup.py"
+ SOURCES ${setup-py}
+ DEPENDS ${setup-py}
+ VERBATIM
+
+ # copy the examples to have them runnable from a relative directory, so
+ # that a locally-installed segyio can be imported
+ COMMAND ${CMAKE_COMMAND} -E
+ copy_directory ${CMAKE_CURRENT_SOURCE_DIR}/examples .
+
+ # do the same to tests. running through setup.py test is *very* slow, so
+ # invoke unittest manually from the build directory. more importantly,
+ # setup.py test will pollute the source directory with egg info and
+ # extensions, which is unacceptable in a cmake world
+ COMMAND ${CMAKE_COMMAND} -E
+ copy_directory ${CMAKE_CURRENT_SOURCE_DIR}/test test
+
+ # setuptools on windows breaks spectacularly when the library isn't
+ # available in the same directory, and build_ext --library-dirs is not
+ # support on msvc is not supported, so we must copy out the libsegyio core
+ # object and put it here
+ COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:segyio-shared>
+ $<TARGET_FILE_NAME:segyio-shared>
+
+ COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_LINKER_FILE:segyio-shared>
+ $<TARGET_LINKER_FILE_NAME:segyio-shared>
+
+ # install the lib in the build-dir so that the examples can load that from
+ # current working dir
+ COMMAND ${python} ${setup-py} ${setup-py-libdir} install_lib -d .
+)
+
+add_dependencies(segyio-python segyio-shared)
+
+# write egg_info to the build dir in order not to pollute the source directory
+# and install as if it was through some other distro by using single-version,
+# so that install won't die on possibly missing pythonpath
+# setup.py install doesn't respect DESTDIR, so "force" it by changing the
+# --root if DESTDIR is passed
+install(CODE "
+if (DEFINED ENV{DESTDIR})
+ get_filename_component(abs-destdir \"\$ENV{DESTDIR}\" ABSOLUTE)
+ set(root_destdir --root=\${abs-destdir})
+endif()
+
+execute_process(COMMAND
+${python} ${setup-py}
+ install_egg_info --install-dir .
+ egg_info --egg-base .
+ install --prefix=${CMAKE_INSTALL_PREFIX}
+ --single-version-externally-managed
+ --record installed-files
+ \${root_destdir}
+WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+)")
+
+if(NOT BUILD_TESTING)
+ return()
+endif()
+
+file(GLOB sgys "${testdata}/*.sgy")
foreach (sgy ${sgys})
get_filename_component(fl ${sgy} NAME)
configure_file(${sgy} test-data/${fl} COPYONLY)
endforeach ()
-configure_file(test/test_context.py test/test_context.py COPYONLY)
-add_python_test(python.segy test/segy.py)
-add_python_test(python.h.segy test/segyio_c.py)
-add_python_test(python.enum.segy test/segyioenum.py)
-add_python_test(python.tools test/tools.py)
-add_python_test(python.context test/context.py)
+set(py-test ${python} -m unittest -v)
+add_test(NAME python.segy COMMAND ${py-test} test.segy)
+add_test(NAME python.h.segy COMMAND ${py-test} test.segyio_c)
+add_test(NAME python.enum.segy COMMAND ${py-test} test.segyioenum)
+add_test(NAME python.tools COMMAND ${py-test} test.tools)
+add_test(NAME python.context COMMAND ${py-test} test.context)
-configure_file(${CMAKE_SOURCE_DIR}/test-data/small.sgy
+configure_file(${testdata}/small.sgy
test-data/write.sgy
COPYONLY)
-add_python_example(pysegyio python.example.about examples/about.py test-data/small.sgy INLINE_3D CROSSLINE_3D)
-add_python_example(pysegyio python.example.write examples/write.py test-data/write.sgy)
-add_python_example(pysegyio python.example.makefile examples/make-file.py test-data/large-file.sgy 20 1 20 1 20)
-add_python_example(pysegyio python.example.makepsfile examples/make-ps-file.py test-data/small-prestack.sgy 10 1 5 1 4 1 3)
-add_python_example(pysegyio python.example.subcube examples/copy-sub-cube.py test-data/small.sgy test-data/copy.sgy)
-add_python_example(pysegyio python.example.rotate examples/make-rotated-copies.py test-data/small.sgy)
-add_python_example(pysegyio python.example.scan_min_max examples/scan_min_max.py test-data/small.sgy)
+
+add_test(NAME python.example.about COMMAND ${python} about.py test-data/small.sgy INLINE_3D CROSSLINE_3D)
+add_test(NAME python.example.write COMMAND ${python} write.py test-data/write.sgy)
+add_test(NAME python.example.makefile COMMAND ${python} make-file.py test-data/large-file.sgy 20 1 20 1 20)
+add_test(NAME python.example.makepsfile COMMAND ${python} make-ps-file.py test-data/small-prestack.sgy 10 1 5 1 4 1 3)
+add_test(NAME python.example.subcube COMMAND ${python} copy-sub-cube.py test-data/small.sgy test-data/copy.sgy)
+add_test(NAME python.example.rotate COMMAND ${python} make-rotated-copies.py test-data/small.sgy)
+add_test(NAME python.example.scan_min_max COMMAND ${python} scan_min_max.py test-data/small.sgy)
diff --git a/python/examples/write.py b/python/examples/write.py
index 68ebb47..bc3a21a 100644
--- a/python/examples/write.py
+++ b/python/examples/write.py
@@ -76,7 +76,7 @@ def main():
# accessing a non-existing inline will raise a KeyError
try:
src.iline[5000]
- assert(False)
+ sys.exit("Was able to access non-existing inline")
except KeyError as e:
print(str(e))
diff --git a/python/segyio/__init__.py b/python/segyio/__init__.py
index bd95ee0..9d91ee3 100644
--- a/python/segyio/__init__.py
+++ b/python/segyio/__init__.py
@@ -90,7 +90,11 @@ from .segy import SegyFile, spec
from .tools import dt, sample_indexes, create_text_header, native
from .tools import collect, cube
-__version__ = '1.0.4'
+try:
+ from .version import version as __version__
+except ImportError:
+ __version__ = '0.0.0'
+
__copyright__ = 'Copyright 2016, Statoil ASA'
__license__ = 'GNU Lesser General Public License version 3'
__status__ = 'Production'
diff --git a/python/segyio/_gather.py b/python/segyio/_gather.py
index e4be93e..55c8cfb 100644
--- a/python/segyio/_gather.py
+++ b/python/segyio/_gather.py
@@ -58,25 +58,42 @@ class Gather:
self.trace[self._getindex(il, xl, x, sort)]
for x in xs)
- # gather[:,:,:]
+ # gather[:,:,:], gather[int,:,:], gather[:,int,:]
+ # gather[:,:,int] etc
def gen():
- ils, _ = self.iline._indices(il, None)
- xls, _ = self.xline._indices(xl, None)
+ # precompute the xline number -> xline offset
+ xlinds = { xlno: i for i, xlno in enumerate(self.xline.lines) }
+ ofinds = { ofno: i for i, ofno in enumerate(self.offsets) }
+
+ # doing range over gathers is VERY expensive, because every lookup
+ # with a naive implementations would call _getindex to map lineno
+ # -> trace index. However, ranges over gathers are done on a
+ # by-line basis so lines can be buffered, and traces can be read
+ # from the iline. This is the least efficient when there are very
+ # few traces read per inline, but huge savings with larger subcubes
+ last_il = self.iline.lines[-1] + 1
+ last_xl = self.xline.lines[-1] + 1
+
+ il_slice = il if isslice(il) else slice(il, il+1)
+ xl_slice = xl if isslice(xl) else slice(xl, xl+1)
+
+ il_range = range(*il_slice.indices(last_il))
+ xl_range = range(*xl_slice.indices(last_xl))
- # gather[:, :, int]
- # i.e. every yielded array is 1-dimensional
if not isslice(off):
- for i, x in itertools.product(ils, xls):
- yield self.trace[self._getindex(i, x, off, sort)]
+ for iline in self.iline[il_slice, off]:
+ for xlno in xl_range:
+ yield iline[xlinds[xlno]]
+
return
if len(xs) == 0:
- for _, _ in itertools.product(ils, xls): yield empty
+ for _, _ in itertools.product(ilrange, xlrange): yield empty
return
- for i, x in itertools.product(ils, xls):
- yield tools.collect(
- self.trace[self._getindex(i, x, o, sort)]
- for o in xs)
+ for ilno in il_range:
+ iline = tools.collect(self.iline[ilno, off])
+ for x in xl_range:
+ yield iline[:, xlinds[x]]
return gen()
diff --git a/python/segyio/_segyio.c b/python/segyio/segyio.cpp
similarity index 96%
rename from python/segyio/_segyio.c
rename to python/segyio/segyio.cpp
index f8f553e..c8473e0 100644
--- a/python/segyio/_segyio.c
+++ b/python/segyio/segyio.cpp
@@ -45,7 +45,7 @@ static segy_file *get_FILE_pointer_from_capsule(PyObject *capsule) {
return NULL;
}
- segy_file *p_FILE = PyCapsule_GetPointer(capsule, "segy_file*");
+ segy_file *p_FILE = (segy_file*)PyCapsule_GetPointer(capsule, "segy_file*");
if (!p_FILE) {
PyErr_SetString(PyExc_ValueError, "File Handle is NULL");
@@ -233,7 +233,7 @@ static PyObject *py_read_texthdr(PyObject *self, PyObject *args) {
segy_file *p_FILE = get_FILE_pointer_from_capsule(file_capsule);
- char *buffer = malloc(sizeof(char) * (segy_textheader_size()));
+ char *buffer = (char*)malloc(sizeof(char) * (segy_textheader_size()));
int error = index == 0
? segy_read_textheader(p_FILE, buffer)
@@ -279,13 +279,13 @@ static char *get_header_pointer_from_capsule(PyObject *capsule, int *length) {
if (length) {
*length = segy_binheader_size();
}
- return PyCapsule_GetPointer(capsule, "BinaryHeader=char*");
+ return (char*)PyCapsule_GetPointer(capsule, "BinaryHeader=char*");
} else if (PyCapsule_IsValid(capsule, "TraceHeader=char*")) {
if (length) {
*length = SEGY_TRACE_HEADER_SIZE;
}
- return PyCapsule_GetPointer(capsule, "TraceHeader=char*");
+ return (char*)PyCapsule_GetPointer(capsule, "TraceHeader=char*");
}
PyErr_SetString(PyExc_TypeError, "The object was not a header type");
return NULL;
@@ -359,7 +359,7 @@ static void *py_binary_header_destructor(PyObject *capsule) {
static PyObject *py_empty_binaryhdr(PyObject *self) {
errno = 0;
- char *buffer = calloc(segy_binheader_size(), sizeof(char));
+ char *buffer = (char*)calloc(segy_binheader_size(), sizeof(char));
return PyCapsule_New(buffer, "BinaryHeader=char*", (PyCapsule_Destructor) py_binary_header_destructor);
}
@@ -373,7 +373,7 @@ static PyObject *py_read_binaryhdr(PyObject *self, PyObject *args) {
if (PyErr_Occurred()) { return NULL; }
- char *buffer = malloc(sizeof(char) * (segy_binheader_size()));
+ char *buffer = (char*)malloc(sizeof(char) * (segy_binheader_size()));
int error = segy_binheader(p_FILE, buffer);
@@ -412,7 +412,7 @@ static char *get_trace_header_pointer_from_capsule(PyObject *capsule) {
PyErr_Format(PyExc_TypeError, "The object was not of type TraceHeader.");
return NULL;
}
- return PyCapsule_GetPointer(capsule, "TraceHeader=char*");
+ return (char*)PyCapsule_GetPointer(capsule, "TraceHeader=char*");
}
static void *py_trace_header_destructor(PyObject *capsule) {
@@ -423,7 +423,7 @@ static void *py_trace_header_destructor(PyObject *capsule) {
static PyObject *py_empty_trace_header(PyObject *self) {
errno = 0;
- char *buffer = calloc(SEGY_TRACE_HEADER_SIZE, sizeof(char));
+ char *buffer = (char*)calloc(SEGY_TRACE_HEADER_SIZE, sizeof(char));
return PyCapsule_New(buffer, "TraceHeader=char*", (PyCapsule_Destructor) py_trace_header_destructor);
}
@@ -517,7 +517,7 @@ static PyObject *py_field_forall(PyObject *self, PyObject *args ) {
start,
stop,
step,
- buffer.buf,
+ (int*)buffer.buf,
trace0,
trace_bsize );
@@ -576,8 +576,8 @@ static PyObject *py_field_foreach(PyObject *self, PyObject *args ) {
return NULL;
}
- const int* ind = bufindices.buf;
- int* out = bufout.buf;
+ const int* ind = (int*)bufindices.buf;
+ int* out = (int*)bufout.buf;
for( int i = 0; i < len; ++i ) {
int err = segy_field_forall( fp, field,
ind[ i ],
@@ -779,7 +779,7 @@ static PyObject *py_init_cube_metrics(PyObject *self, PyObject *args) {
}
static Py_buffer check_and_get_buffer(PyObject *object, const char *name, unsigned int expected) {
- static const Py_buffer zero_buffer;
+ static const Py_buffer zero_buffer = { 0 };
Py_buffer buffer = zero_buffer;
if (!PyObject_CheckBuffer(object)) {
PyErr_Format(PyExc_TypeError, "The destination for %s is not a buffer object", name);
@@ -866,7 +866,7 @@ static PyObject *py_init_indices(PyObject *self, PyObject *args) {
PyArg_Parse(PyDict_GetItemString(metrics, "trace0"), "l", &trace0);
PyArg_Parse(PyDict_GetItemString(metrics, "trace_bsize"), "i", &trace_bsize);
- int error = segy_inline_indices(p_FILE, il_field, sorting, iline_count, xline_count, offset_count, iline_buffer.buf,
+ int error = segy_inline_indices(p_FILE, il_field, sorting, iline_count, xline_count, offset_count, (int*)iline_buffer.buf,
trace0, trace_bsize);
if (error != 0) {
@@ -874,7 +874,7 @@ static PyObject *py_init_indices(PyObject *self, PyObject *args) {
goto cleanup;
}
- error = segy_crossline_indices(p_FILE, xl_field, sorting, iline_count, xline_count, offset_count, xline_buffer.buf,
+ error = segy_crossline_indices(p_FILE, xl_field, sorting, iline_count, xline_count, offset_count, (int*)xline_buffer.buf,
trace0, trace_bsize);
if (error != 0) {
@@ -883,7 +883,7 @@ static PyObject *py_init_indices(PyObject *self, PyObject *args) {
}
error = segy_offset_indices( p_FILE, offset_field, offset_count,
- offsets_buffer.buf,
+ (int*)offsets_buffer.buf,
trace0, trace_bsize );
if (error != 0) {
@@ -924,7 +924,7 @@ static PyObject *py_fread_trace0(PyObject *self, PyObject *args) {
int trace_no;
int linenos_sz = PyObject_Length(indices_object);
- int error = segy_line_trace0(lineno, other_line_length, stride, offsets, buffer.buf, linenos_sz, &trace_no);
+ int error = segy_line_trace0(lineno, other_line_length, stride, offsets, (int*)buffer.buf, linenos_sz, &trace_no);
PyBuffer_Release( &buffer );
if (error != 0) {
@@ -966,7 +966,7 @@ static PyObject *py_read_trace(PyObject *self, PyObject *args) {
PyObject_GetBuffer(buffer_out, &buffer, PyBUF_FORMAT | PyBUF_C_CONTIGUOUS | PyBUF_WRITEABLE);
int error = 0;
- float* buf = buffer.buf;
+ float* buf = (float*)buffer.buf;
Py_ssize_t i;
for( i = 0; error == 0 && i < length; ++i, buf += samples ) {
@@ -974,7 +974,7 @@ static PyObject *py_read_trace(PyObject *self, PyObject *args) {
}
long long bufsize = (long long) length * samples;
- int conv_error = segy_to_native(format, bufsize, buffer.buf);
+ int conv_error = segy_to_native(format, bufsize, (float*)buffer.buf);
PyBuffer_Release( &buffer );
if (error != 0) {
@@ -1013,7 +1013,7 @@ static PyObject *py_write_trace(PyObject *self, PyObject *args) {
Py_buffer buffer;
PyObject_GetBuffer(buffer_in, &buffer, PyBUF_FORMAT | PyBUF_C_CONTIGUOUS | PyBUF_WRITEABLE);
- int error = segy_from_native(format, samples, buffer.buf);
+ int error = segy_from_native(format, samples, (float*)buffer.buf);
if (error != 0) {
PyErr_SetString(PyExc_TypeError, "Unable to convert buffer from native format.");
@@ -1021,8 +1021,8 @@ static PyObject *py_write_trace(PyObject *self, PyObject *args) {
return NULL;
}
- error = segy_writetrace(p_FILE, trace_no, buffer.buf, trace0, trace_bsize);
- int conv_error = segy_to_native(format, samples, buffer.buf);
+ error = segy_writetrace(p_FILE, trace_no, (float*)buffer.buf, trace0, trace_bsize);
+ int conv_error = segy_to_native(format, samples, (float*)buffer.buf);
PyBuffer_Release( &buffer );
if (error != 0) {
@@ -1068,14 +1068,14 @@ static PyObject *py_read_line(PyObject *self, PyObject *args) {
Py_buffer buffer;
PyObject_GetBuffer(buffer_in, &buffer, PyBUF_FORMAT | PyBUF_C_CONTIGUOUS | PyBUF_WRITEABLE);
- int error = segy_read_line(p_FILE, line_trace0, line_length, stride, offsets, buffer.buf, trace0, trace_bsize);
+ int error = segy_read_line(p_FILE, line_trace0, line_length, stride, offsets, (float*)buffer.buf, trace0, trace_bsize);
if (error != 0) {
PyBuffer_Release( &buffer );
return py_handle_segy_error_with_index_and_name(error, errno, line_trace0, "Line");
}
- error = segy_to_native(format, samples * line_length, buffer.buf);
+ error = segy_to_native(format, samples * line_length, (float*)buffer.buf);
PyBuffer_Release( &buffer );
if (error != 0) {
@@ -1120,7 +1120,7 @@ static PyObject *py_read_depth_slice(PyObject *self, PyObject *args) {
Py_ssize_t trace_no = 0;
int error = 0;
- float* buf = buffer.buf;
+ float* buf = (float*)buffer.buf;
for(trace_no = 0; error == 0 && trace_no < count; ++trace_no) {
error = segy_readsubtr(p_FILE,
@@ -1138,7 +1138,7 @@ static PyObject *py_read_depth_slice(PyObject *self, PyObject *args) {
return py_handle_segy_error_with_index_and_name(error, errno, trace_no, "Depth");
}
- error = segy_to_native(format, count, buffer.buf);
+ error = segy_to_native(format, count, (float*)buffer.buf);
PyBuffer_Release( &buffer );
if (error != 0) {
@@ -1160,7 +1160,7 @@ static PyObject * py_format(PyObject *self, PyObject *args) {
PyObject_GetBuffer( out, &buffer,
PyBUF_FORMAT | PyBUF_C_CONTIGUOUS | PyBUF_WRITEABLE );
- int err = segy_to_native( format, buffer.len / buffer.itemsize, buffer.buf );
+ int err = segy_to_native( format, buffer.len / buffer.itemsize, (float*)buffer.buf );
PyBuffer_Release( &buffer );
diff --git a/python/segyio/version.py b/python/segyio/version.py
new file mode 100644
index 0000000..5ef1db2
--- /dev/null
+++ b/python/segyio/version.py
@@ -0,0 +1 @@
+version = '1.3.6'
diff --git a/python/setup.py.in b/python/setup.py.in
deleted file mode 100644
index b0b9436..0000000
--- a/python/setup.py.in
+++ /dev/null
@@ -1,78 +0,0 @@
-#!/usr/bin/env python
-
-from setuptools import setup, Extension
-
-long_description = """
-=======
-SEGY IO
-=======
-
-Introduction
-------------
-
-Segyio is a small LGPL licensed C library for easy interaction with SEG Y
-formatted seismic data, with language bindings for Python and Matlab. Segyio is
-an attempt to create an easy-to-use, embeddable, community-oriented library for
-seismic applications. Features are added as they are needed; suggestions and
-contributions of all kinds are very welcome.
-
-Feature summary
----------------
- * A low-level C interface with few assumptions; easy to bind to other
- languages.
- * Read and write binary and textual headers.
- * Read and write traces, trace headers.
- * Easy to use and native-feeling python interface with numpy integration.
-
-Project goals
--------------
-
-Segyio does necessarily attempt to be the end-all of SEG-Y interactions;
-rather, we aim to lower the barrier to interacting with SEG-Y files for
-embedding, new applications or free-standing programs.
-
-Additionally, the aim is not to support the full standard or all exotic (but
-correctly) formatted files out there. Some assumptions are made, such as:
-
- * All traces in a file are assumed to be of the same sample size.
- * It is assumed all lines have the same number of traces.
-
-The writing functionality in Segyio is largely meant to *modify* or adapt
-files. A file created from scratch is not necessarily a to-spec SEG-Y file, as
-we only necessarily write the header fields segyio needs to make sense of the
-geometry. It is still highly recommended that SEG-Y files are maintained and
-written according to specification, but segyio does not mandate this.
-
-"""
-
-setup(name='${PYCMAKE_PACKAGE_NAME}',
- version='${PYCMAKE_VERSION}',
- description='Simple & fast IO for SEG-Y files',
- long_description=long_description,
- author='Statoil ASA',
- author_email='fg_gpl at statoil.com',
- url='https://github.com/Statoil/segyio',
- packages=['segyio'],
- package_data={'': ['License', 'README']},
- license='LGPL-3.0',
- ext_modules=[${PYCMAKE_EXTENSIONS}],
- platforms='any',
- requires=['numpy'],
- install_requires=['numpy'],
- classifiers=[
- 'Development Status :: 5 - Production/Stable',
- 'Environment :: Other Environment',
- 'Intended Audience :: Developers',
- 'Intended Audience :: Science/Research',
- 'License :: OSI Approved :: GNU Lesser General Public License v3 or later (LGPLv3+)',
- 'Natural Language :: English',
- 'Programming Language :: Python',
- 'Programming Language :: Python :: 2.7',
- 'Programming Language :: Python :: 3.5',
- 'Programming Language :: Python :: 3.6',
- 'Topic :: Scientific/Engineering',
- 'Topic :: Scientific/Engineering :: Physics',
- 'Topic :: Software Development :: Libraries',
- 'Topic :: Utilities'
- ]
- )
diff --git a/python/test/__init__.py b/python/test/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/python/test/context.py b/python/test/context.py
index 2e2ad0a..72e0c29 100644
--- a/python/test/context.py
+++ b/python/test/context.py
@@ -1,10 +1,12 @@
+from __future__ import absolute_import
+
import os
-from unittest import TestCase
+import unittest
-from test_context import TestContext
+from .test_context import TestContext
-class TestContextTest(TestCase):
+class TestContextTest(unittest.TestCase):
def test_test_context(self):
original_cwd = os.getcwd()
with TestContext() as context:
@@ -30,3 +32,6 @@ class TestContextTest(TestCase):
self.assertTrue(os.path.exists("small.sgy"))
self.assertTrue(os.path.exists("test/small.sgy"))
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/python/test/segy.py b/python/test/segy.py
index f68fa32..c9b03ce 100644
--- a/python/test/segy.py
+++ b/python/test/segy.py
@@ -1,9 +1,11 @@
+from __future__ import absolute_import
+
from types import GeneratorType
import itertools
import numpy as np
-from unittest import TestCase
-from test_context import TestContext
+import unittest
+from .test_context import TestContext
import segyio
from segyio import TraceField, BinField
@@ -50,7 +52,7 @@ def mklines(fname):
dst.header.xline[xl] = { TraceField.CROSSLINE_3D: xl }
-class TestSegy(TestCase):
+class TestSegy(unittest.TestCase):
def setUp(self):
self.filename = "test-data/small.sgy"
@@ -998,3 +1000,6 @@ class TestSegy(TestCase):
f.depth_slice = [buf * i for i in range(len(f.depth_slice))] # assign to all depths
for index, depth_slice in enumerate(f.depth_slice):
self.assertTrue(np.allclose(depth_slice, buf * index))
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/python/test/segyio_c.py b/python/test/segyio_c.py
index 708e1f8..8853c99 100644
--- a/python/test/segyio_c.py
+++ b/python/test/segyio_c.py
@@ -1,12 +1,14 @@
-from unittest import TestCase
+from __future__ import absolute_import
+
+import unittest
import numpy
import segyio
import segyio._segyio as _segyio
-from test_context import TestContext
+from .test_context import TestContext
-class _segyioTests(TestCase):
+class _segyioTests(unittest.TestCase):
def setUp(self):
self.filename = "test-data/small.sgy"
@@ -483,3 +485,5 @@ class _segyioTests(TestCase):
with self.assertRaises(KeyError):
d = _segyio.fread_trace0(25, 1, 1, 1, indices, "depth")
+if __name__ == '__main__':
+ unittest.main()
diff --git a/python/test/tools.py b/python/test/tools.py
index 415aa3f..692cadf 100644
--- a/python/test/tools.py
+++ b/python/test/tools.py
@@ -1,15 +1,16 @@
+from __future__ import absolute_import
from __future__ import division
-from unittest import TestCase
+import unittest
import math
from segyio import BinField
from segyio import TraceField
import numpy as np
-from test_context import TestContext
+from .test_context import TestContext
import segyio
-class ToolsTest(TestCase):
+class ToolsTest(unittest.TestCase):
def setUp(self):
self.filename = "test-data/small.sgy"
self.prestack = "test-data/small-ps.sgy"
@@ -127,3 +128,6 @@ class ToolsTest(TestCase):
close(angle, rotation(f, line = 'iline'), places = 3)
close(right, rotation(f, line = 'slow'), places = 3)
close(right, rotation(f, line = 'xline'), places = 3)
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000..421cf6d
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1 @@
+numpy >= 1.10
diff --git a/requires.txt b/requires.txt
deleted file mode 100644
index 334a07d..0000000
--- a/requires.txt
+++ /dev/null
@@ -1 +0,0 @@
-numpy (>=1.10)
diff --git a/setup.py b/setup.py
index 82542f2..617c636 100644
--- a/setup.py
+++ b/setup.py
@@ -1,12 +1,8 @@
#!/usr/bin/env python
-from distutils.core import setup, Extension
-
-_segyio = Extension('segyio._segyio',
- sources=['python/segyio/_segyio.c', 'lib/src/segy.c'],
- include_dirs=['lib/src', 'lib/include'],
- define_macros=[('HAVE_MMAP', 1), ('HAVE_NETINET_IN_H', 1)],
- extra_compile_args=['-std=c99'])
+import os
+import sys
+from setuptools import setup, Extension
long_description = """
=======
@@ -51,21 +47,62 @@ written according to specification, but segyio does not mandate this.
"""
-setup(name='SegyIO',
- version='1.0.4',
- description='IO library for SEG-Y files',
+def src(x):
+ root = os.path.dirname( __file__ )
+ return os.path.abspath(os.path.join(root, x))
+
+extra_libs = ['m'] if not 'win' in sys.platform else []
+
+def getversion():
+ # if this is a tarball distribution, the .git-directory won't be avilable
+ # and setuptools_scm will crash hard. good tarballs are built with a
+ # pre-generated version.py, so parse that and extract version from it
+ if os.path.isdir(src('.git')):
+ return {
+ 'use_scm_version': {
+ 'root': src(''),
+ 'write_to': src('python/segyio/version.py')
+ }
+ }
+
+
+ pkgversion = { 'version': '0.0.0' }
+ versionfile = src('python/segyio/version.py')
+
+ if not os.path.exists(versionfile):
+ return pkgversion
+
+ import ast
+ with open(versionfile) as f:
+ root = ast.parse(f.read())
+
+ for node in ast.walk(root):
+ if not isinstance(node, ast.Assign): continue
+ if len(node.targets) == 1 and node.targets[0].id == 'version':
+ pkgversion['version'] = node.value.s
+
+ return pkgversion
+
+setup(name='segyio',
+ description='Simple & fast IO for SEG-Y files',
long_description=long_description,
author='Statoil ASA',
- author_email='ert at statoil.com',
- url='https://github.com/Statoil/SegyIO',
+ author_email='fg_gpl at statoil.com',
+ url='https://github.com/Statoil/segyio',
+ package_dir={'' : src('python')},
packages=['segyio'],
- package_dir={'': 'python'},
- package_data={'': ['License.md']},
+ package_data={'': ['License', 'README']},
license='LGPL-3.0',
- ext_modules=[_segyio],
+ ext_modules=[Extension('segyio._segyio',
+ sources=[src('python/segyio/segyio.cpp')],
+ include_dirs=[src('lib/include')],
+ libraries=['segyio'] + extra_libs
+ )],
platforms='any',
requires=['numpy'],
install_requires=['numpy'],
+ test_suite='test',
+ setup_requires=['setuptools_scm'],
classifiers=[
'Development Status :: 5 - Production/Stable',
'Environment :: Other Environment',
@@ -73,12 +110,14 @@ setup(name='SegyIO',
'Intended Audience :: Science/Research',
'License :: OSI Approved :: GNU Lesser General Public License v3 or later (LGPLv3+)',
'Natural Language :: English',
- 'Operating System :: OS Independent',
- 'Programming Language :: C',
+ 'Programming Language :: Python',
'Programming Language :: Python :: 2.7',
+ 'Programming Language :: Python :: 3.5',
+ 'Programming Language :: Python :: 3.6',
'Topic :: Scientific/Engineering',
'Topic :: Scientific/Engineering :: Physics',
'Topic :: Software Development :: Libraries',
'Topic :: Utilities'
- ]
+ ],
+ **getversion()
)
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/debian-science/packages/segyio.git
More information about the debian-science-commits
mailing list