diff --git a/cpp/cmake_modules/BuildUtils.cmake b/cpp/cmake_modules/BuildUtils.cmake index 71eec565be0..56096829c9e 100644 --- a/cpp/cmake_modules/BuildUtils.cmake +++ b/cpp/cmake_modules/BuildUtils.cmake @@ -176,9 +176,12 @@ function(ADD_ARROW_LIB LIB_NAME) BUILD_SHARED BUILD_STATIC CMAKE_PACKAGE_NAME + INSTALL_ARCHIVE_DIR + INSTALL_LIBRARY_DIR + INSTALL_RUNTIME_DIR PKG_CONFIG_NAME - SHARED_LINK_FLAGS - PRECOMPILED_HEADER_LIB) + PRECOMPILED_HEADER_LIB + SHARED_LINK_FLAGS) set(multi_value_args SOURCES PRECOMPILED_HEADERS @@ -258,7 +261,6 @@ function(ADD_ARROW_LIB LIB_NAME) target_precompile_headers(${LIB_NAME}_objlib PRIVATE ${ARG_PRECOMPILED_HEADERS}) endif() set(LIB_DEPS $) - set(LIB_INCLUDES) set(EXTRA_DEPS) if(ARG_OUTPUTS) @@ -287,13 +289,29 @@ function(ADD_ARROW_LIB LIB_NAME) # TODO: add PCH directives set(LIB_DEPS ${ARG_SOURCES}) set(EXTRA_DEPS ${ARG_DEPENDENCIES}) + endif() - if(ARG_EXTRA_INCLUDES) - set(LIB_INCLUDES ${ARG_EXTRA_INCLUDES}) - endif() + if(ARG_EXTRA_INCLUDES) + set(LIB_INCLUDES ${ARG_EXTRA_INCLUDES}) + else() + set(LIB_INCLUDES "") endif() - set(RUNTIME_INSTALL_DIR bin) + if(ARG_INSTALL_ARCHIVE_DIR) + set(INSTALL_ARCHIVE_DIR ${ARG_INSTALL_ARCHIVE_DIR}) + else() + set(INSTALL_ARCHIVE_DIR ${CMAKE_INSTALL_LIBDIR}) + endif() + if(ARG_INSTALL_LIBRARY_DIR) + set(INSTALL_LIBRARY_DIR ${ARG_INSTALL_LIBRARY_DIR}) + else() + set(INSTALL_LIBRARY_DIR ${CMAKE_INSTALL_LIBDIR}) + endif() + if(ARG_INSTALL_RUNTIME_DIR) + set(INSTALL_RUNTIME_DIR ${ARG_INSTALL_RUNTIME_DIR}) + else() + set(INSTALL_RUNTIME_DIR bin) + endif() if(BUILD_SHARED) add_library(${LIB_NAME}_shared SHARED ${LIB_DEPS}) @@ -382,9 +400,9 @@ function(ADD_ARROW_LIB LIB_NAME) install(TARGETS ${LIB_NAME}_shared ${INSTALL_IS_OPTIONAL} EXPORT ${LIB_NAME}_targets - RUNTIME DESTINATION ${RUNTIME_INSTALL_DIR} - LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} - ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} + ARCHIVE DESTINATION ${INSTALL_ARCHIVE_DIR} + LIBRARY DESTINATION ${INSTALL_LIBRARY_DIR} + RUNTIME DESTINATION ${INSTALL_RUNTIME_DIR} INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}) endif() @@ -453,9 +471,9 @@ function(ADD_ARROW_LIB LIB_NAME) install(TARGETS ${LIB_NAME}_static ${INSTALL_IS_OPTIONAL} EXPORT ${LIB_NAME}_targets - RUNTIME DESTINATION ${RUNTIME_INSTALL_DIR} - LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} - ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} + ARCHIVE DESTINATION ${INSTALL_ARCHIVE_DIR} + LIBRARY DESTINATION ${INSTALL_LIBRARY_DIR} + RUNTIME DESTINATION ${INSTALL_RUNTIME_DIR} INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}) endif() diff --git a/cpp/cmake_modules/UseCython.cmake b/cpp/cmake_modules/UseCython.cmake index f2025efb4c9..e15ac59490c 100644 --- a/cpp/cmake_modules/UseCython.cmake +++ b/cpp/cmake_modules/UseCython.cmake @@ -118,7 +118,7 @@ function(compile_pyx get_source_file_property(property_is_public ${pyx_file} CYTHON_PUBLIC) get_source_file_property(property_is_api ${pyx_file} CYTHON_API) if(${property_is_api}) - set(_generated_files "${output_file}" "${_name}.h" "${name}_api.h") + set(_generated_files "${output_file}" "${_name}.h" "${_name}_api.h") elseif(${property_is_public}) set(_generated_files "${output_file}" "${_name}.h") else() diff --git a/cpp/src/arrow/symbols.map b/cpp/src/arrow/symbols.map index 7d4f13fa286..9ef0e404bc0 100644 --- a/cpp/src/arrow/symbols.map +++ b/cpp/src/arrow/symbols.map @@ -32,7 +32,6 @@ }; # Also export C-level helpers arrow_*; - pyarrow_*; # ARROW-14771: export Protobuf symbol table descriptor_table_Flight_2eproto; descriptor_table_FlightSql_2eproto; diff --git a/dev/release/01-prepare-test.rb b/dev/release/01-prepare-test.rb index 808b48d4c4f..b7e0bc0893f 100644 --- a/dev/release/01-prepare-test.rb +++ b/dev/release/01-prepare-test.rb @@ -198,10 +198,10 @@ def test_version_pre_tag ], }, { - path: "python/pyarrow/src/CMakeLists.txt", + path: "python/CMakeLists.txt", hunks: [ - ["-set(ARROW_PYTHON_VERSION \"#{@snapshot_version}\")", - "+set(ARROW_PYTHON_VERSION \"#{@release_version}\")"], + ["-set(PYARROW_VERSION \"#{@snapshot_version}\")", + "+set(PYARROW_VERSION \"#{@release_version}\")"], ], }, { diff --git a/dev/release/post-11-bump-versions-test.rb b/dev/release/post-11-bump-versions-test.rb index 46384d1c023..241d66c56b6 100644 --- a/dev/release/post-11-bump-versions-test.rb +++ b/dev/release/post-11-bump-versions-test.rb @@ -145,10 +145,10 @@ def test_version_post_tag ], }, { - path: "python/pyarrow/src/CMakeLists.txt", + path: "python/CMakeLists.txt", hunks: [ - ["-set(ARROW_PYTHON_VERSION \"#{@snapshot_version}\")", - "+set(ARROW_PYTHON_VERSION \"#{@next_snapshot_version}\")"], + ["-set(PYARROW_VERSION \"#{@snapshot_version}\")", + "+set(PYARROW_VERSION \"#{@next_snapshot_version}\")"], ], }, { diff --git a/dev/release/utils-prepare.sh b/dev/release/utils-prepare.sh index 1e50a9295ec..683f1c7e50e 100644 --- a/dev/release/utils-prepare.sh +++ b/dev/release/utils-prepare.sh @@ -119,11 +119,8 @@ update_versions() { setup.py rm -f setup.py.bak git add setup.py - popd - - pushd "${ARROW_DIR}/python/pyarrow/src" sed -i.bak -E -e \ - "s/^set\(ARROW_PYTHON_VERSION \".+\"\)/set(ARROW_PYTHON_VERSION \"${version}\")/" \ + "s/^set\(PYARROW_VERSION \".+\"\)/set(PYARROW_VERSION \"${version}\")/" \ CMakeLists.txt rm -f CMakeLists.txt.bak git add CMakeLists.txt diff --git a/python/CMakeLists.txt b/python/CMakeLists.txt index bad5e926abb..435a4481350 100644 --- a/python/CMakeLists.txt +++ b/python/CMakeLists.txt @@ -21,6 +21,9 @@ cmake_minimum_required(VERSION 3.2) project(pyarrow) +set(PYARROW_VERSION "11.0.0-SNAPSHOT") +string(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" PYARROW_BASE_VERSION "${PYARROW_VERSION}") + # Running from a Python sdist tarball set(LOCAL_CMAKE_MODULES "${CMAKE_SOURCE_DIR}/cmake_modules") if(EXISTS "${LOCAL_CMAKE_MODULES}") @@ -87,12 +90,14 @@ if("${CMAKE_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_SOURCE_DIR}") option(PYARROW_BUILD_PARQUET_ENCRYPTION "Build the PyArrow Parquet encryption integration" OFF) option(PYARROW_BOOST_USE_SHARED - "Rely on boost shared libraries on linking static parquet" ON) + "Rely on Boost shared libraries on linking static parquet" ON) option(PYARROW_BUILD_PLASMA "Build the PyArrow Plasma integration" OFF) option(PYARROW_USE_TENSORFLOW "Build PyArrow with TensorFlow support" OFF) option(PYARROW_BUILD_ORC "Build the PyArrow ORC integration" OFF) option(PYARROW_BUNDLE_ARROW_CPP "Bundle the Arrow C++ libraries" OFF) option(PYARROW_BUNDLE_BOOST "Bundle the Boost libraries when we bundle Arrow C++" OFF) + option(PYARROW_BUNDLE_CYTHON_CPP "Bundle the C++ files generated by Cython" OFF) + option(PYARROW_BUNDLE_PLASMA_EXECUTABLE "Bundle the plasma-store-server" ON) option(PYARROW_GENERATE_COVERAGE "Build with Cython code coverage enabled" OFF) set(PYARROW_CXXFLAGS "" @@ -100,9 +105,15 @@ if("${CMAKE_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_SOURCE_DIR}") endif() find_program(CCACHE_FOUND ccache) -if(CCACHE_FOUND) - set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ccache) - set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK ccache) +if(CCACHE_FOUND + AND NOT CMAKE_C_COMPILER_LAUNCHER + AND NOT CMAKE_CXX_COMPILER_LAUNCHER) + message(STATUS "Using ccache: ${CCACHE_FOUND}") + set(CMAKE_C_COMPILER_LAUNCHER ${CCACHE_FOUND}) + set(CMAKE_CXX_COMPILER_LAUNCHER ${CCACHE_FOUND}) + # ARROW-3985: let ccache preserve C++ comments, because some of them may be + # meaningful to the compiler + set(ENV{CCACHE_COMMENTS} "1") endif(CCACHE_FOUND) # @@ -223,21 +234,214 @@ include(UseCython) include_directories(SYSTEM ${NUMPY_INCLUDE_DIRS} ${PYTHON_INCLUDE_DIRS} src) +# PyArrow C++ +include(GNUInstallDirs) + +find_package(Arrow REQUIRED) + +set(PYARROW_CPP_ROOT_DIR pyarrow/src) +set(PYARROW_CPP_SOURCE_DIR ${PYARROW_CPP_ROOT_DIR}/arrow/python) +set(PYARROW_CPP_SRCS + ${PYARROW_CPP_SOURCE_DIR}/arrow_to_pandas.cc + ${PYARROW_CPP_SOURCE_DIR}/benchmark.cc + ${PYARROW_CPP_SOURCE_DIR}/common.cc + ${PYARROW_CPP_SOURCE_DIR}/datetime.cc + ${PYARROW_CPP_SOURCE_DIR}/decimal.cc + ${PYARROW_CPP_SOURCE_DIR}/deserialize.cc + ${PYARROW_CPP_SOURCE_DIR}/extension_type.cc + ${PYARROW_CPP_SOURCE_DIR}/gdb.cc + ${PYARROW_CPP_SOURCE_DIR}/helpers.cc + ${PYARROW_CPP_SOURCE_DIR}/inference.cc + ${PYARROW_CPP_SOURCE_DIR}/init.cc + ${PYARROW_CPP_SOURCE_DIR}/io.cc + ${PYARROW_CPP_SOURCE_DIR}/ipc.cc + ${PYARROW_CPP_SOURCE_DIR}/numpy_convert.cc + ${PYARROW_CPP_SOURCE_DIR}/numpy_to_arrow.cc + ${PYARROW_CPP_SOURCE_DIR}/python_test.cc + ${PYARROW_CPP_SOURCE_DIR}/python_to_arrow.cc + ${PYARROW_CPP_SOURCE_DIR}/pyarrow.cc + ${PYARROW_CPP_SOURCE_DIR}/serialize.cc + ${PYARROW_CPP_SOURCE_DIR}/udf.cc) +set_source_files_properties(${PYARROW_CPP_SOURCE_DIR}/init.cc + PROPERTIES SKIP_PRECOMPILE_HEADERS ON + SKIP_UNITY_BUILD_INCLUSION ON) + +set(PYARROW_CPP_SHARED_LINK_LIBS) +set(PYARROW_CPP_SHARED_PRIVATE_LINK_LIBS) +set(PYARROW_CPP_SHARED_INSTALL_INTERFACE_LIBS) +set(PYARROW_CPP_STATIC_LINK_LIBS) +set(PYARROW_CPP_STATIC_INSTALL_INTERFACE_LIBS) + # -# Dependencies +# Arrow vs PyArrow C++ options # +# Check all the options from Arrow and PyArrow C++ to be in line +if(PYARROW_BUILD_DATASET) + if(NOT ARROW_DATASET) + message(FATAL_ERROR "You must build Arrow C++ with ARROW_DATASET=ON") + endif() + find_package(ArrowDataset REQUIRED) + list(APPEND PYARROW_CPP_SHARED_LINK_LIBS ArrowDataset::arrow_dataset_shared) + list(APPEND PYARROW_CPP_SHARED_INSTALL_INTERFACE_LIBS + ArrowDataset::arrow_dataset_shared) + list(APPEND PYARROW_CPP_STATIC_LINK_LIBS ArrowDataset::arrow_dataset_static) + list(APPEND PYARROW_CPP_STATIC_INSTALL_INTERFACE_LIBS + ArrowDataset::arrow_dataset_static) +endif() + +if(PYARROW_BUILD_PARQUET OR PYARROW_BUILD_PARQUET_ENCRYPTION) + if(NOT ARROW_PARQUET) + message(FATAL_ERROR "You must build Arrow C++ with ARROW_PARQUET=ON") + endif() + find_package(Parquet REQUIRED) +endif() + +if(PYARROW_BUILD_PARQUET_ENCRYPTION) + if(PARQUET_REQUIRE_ENCRYPTION) + list(APPEND PYARROW_CPP_SRCS ${PYARROW_CPP_SOURCE_DIR}/parquet_encryption.cc) + list(APPEND PYARROW_CPP_SHARED_LINK_LIBS Parquet::parquet_shared) + list(APPEND PYARROW_CPP_SHARED_INSTALL_INTERFACE_LIBS Parquet::parquet_shared) + list(APPEND PYARROW_CPP_STATIC_LINK_LIBS Parquet::parquet_static) + list(APPEND PYARROW_CPP_STATIC_INSTALL_INTERFACE_LIBS Parquet::parquet_static) + else() + message(FATAL_ERROR "You must build Arrow C++ with PARQUET_REQUIRE_ENCRYPTION=ON") + endif() +endif() + +if(PYARROW_BUILD_HDFS) + if(NOT ARROW_HDFS) + message(FATAL_ERROR "You must build Arrow C++ with ARROW_HDFS=ON") + endif() +endif() + +# Check for only Arrow C++ options +if(ARROW_CSV) + list(APPEND PYARROW_CPP_SRCS ${PYARROW_CPP_SOURCE_DIR}/csv.cc) +endif() + +if(ARROW_FILESYSTEM) + list(APPEND PYARROW_CPP_SRCS ${PYARROW_CPP_SOURCE_DIR}/filesystem.cc) +endif() + +if(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang") + set_property(SOURCE ${PYARROW_CPP_SOURCE_DIR}/pyarrow.cc + APPEND_STRING + PROPERTY COMPILE_FLAGS " -Wno-cast-qual ") +endif() + +if(NOT PYARROW_CPP_SHARED_LINK_LIBS) + list(APPEND PYARROW_CPP_SHARED_LINK_LIBS Arrow::arrow_shared) +endif() +if(NOT PYARROW_CPP_SHARED_INSTALL_INTERFACE_LIBS) + list(APPEND PYARROW_CPP_SHARED_INSTALL_INTERFACE_LIBS Arrow::arrow_shared) +endif() +if(NOT PYARROW_CPP_STATIC_LINK_LIBS) + list(APPEND PYARROW_CPP_STATIC_LINK_LIBS Arrow::arrow_static) +endif() +list(APPEND PYARROW_CPP_STATIC_LINK_LIBS ${PYTHON_OTHER_LIBS}) +if(NOT PYARROW_CPP_STATIC_INSTALL_INTERFACE_LIBS) + list(APPEND PYARROW_CPP_STATIC_INSTALL_INTERFACE_LIBS Arrow::arrow_static) +endif() + +if(WIN32) + list(APPEND PYARROW_CPP_SHARED_LINK_LIBS ${PYTHON_LIBRARIES} ${PYTHON_OTHER_LIBS}) +endif() + +add_arrow_lib(arrow_python + SOURCES + ${PYARROW_CPP_SRCS} + PRECOMPILED_HEADERS + "$<$:${PYARROW_CPP_SOURCE_DIR}/pch.h>" + INSTALL_ARCHIVE_DIR + "." + INSTALL_LIBRARY_DIR + "." + INSTALL_RUNTIME_DIR + "." + OUTPUTS + PYARROW_CPP_LIBRARIES + SHARED_LINK_LIBS + ${PYARROW_CPP_SHARED_LINK_LIBS} + SHARED_PRIVATE_LINK_LIBS + ${PYARROW_CPP_SHARED_PRIVATE_LINK_LIBS} + SHARED_INSTALL_INTERFACE_LIBS + ${PYARROW_CPP_SHARED_INSTALL_INTERFACE_LIBS} + STATIC_LINK_LIBS + ${PYARROW_CPP_STATIC_LINK_LIBS} + STATIC_INSTALL_INTERFACE_LIBS + ${PYARROW_CPP_STATIC_INSTALL_INTERFACE_LIBS} + EXTRA_INCLUDES + ${PYARROW_CPP_ROOT_DIR}) + +foreach(LIB_TARGET ${PYARROW_CPP_LIBRARIES}) + target_compile_definitions(${LIB_TARGET} PRIVATE ARROW_PYTHON_EXPORTING) +endforeach() + +if(ARROW_BUILD_STATIC AND MSVC) + target_compile_definitions(arrow_python_static PUBLIC ARROW_PYTHON_STATIC) +endif() + +set(PYARROW_CPP_FLIGHT_SRCS ${PYARROW_CPP_SOURCE_DIR}/flight.cc) if(PYARROW_BUILD_FLIGHT) - set(ARROW_FLIGHT TRUE) + if(NOT ARROW_FLIGHT) + message(FATAL_ERROR "You must build Arrow C++ with ARROW_FLIGHT=ON") + endif() + # Must link to shared libarrow_flight: we don't want to link more than one + # copy of gRPC into the eventual Cython shared object, otherwise gRPC calls + # fail with weird errors due to multiple copies of global static state (The + # other solution is to link gRPC shared everywhere instead of statically only + # in Flight) + if(NOT ARROW_BUILD_SHARED) + message(FATAL_ERROR "You must build Arrow C++ with ARROW_BUILD_SHARED=ON") + endif() + find_package(ArrowFlight REQUIRED) + + add_arrow_lib(arrow_python_flight + SOURCES + ${PYARROW_CPP_FLIGHT_SRCS} + INSTALL_ARCHIVE_DIR + "." + INSTALL_LIBRARY_DIR + "." + INSTALL_RUNTIME_DIR + "." + OUTPUTS + PYARROW_CPP_FLIGHT_LIBRARIES + SHARED_LINK_LIBS + arrow_python_shared + ArrowFlight::arrow_flight_shared + SHARED_INSTALL_INTERFACE_LIBS + arrow_python_shared + ArrowFlight::arrow_flight_shared + STATIC_LINK_LIBS + arrow_python_static + ArrowFlight::arrow_flight_static + STATIC_INSTALL_INTERFACE_LIBS + arrow_python_static + ArrowFlight::arrow_flight_static) + + foreach(LIB_TARGET ${PYARROW_CPP_FLIGHT_LIBRARIES}) + target_compile_definitions(${LIB_TARGET} PRIVATE ARROW_PYFLIGHT_EXPORTING) + endforeach() + + if(ARROW_BUILD_STATIC AND MSVC) + target_compile_definitions(arrow_python_flight_static PUBLIC ARROW_PYFLIGHT_STATIC) + endif() endif() -if(PYARROW_BUILD_SUBSTRAIT) - set(ARROW_SUBSTRAIT TRUE) +if(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang") + # Clang, be quiet. Python C API has lots of macros + set_property(SOURCE ${PYARROW_CPP_SRCS} ${PYARROW_CPP_FLIGHT_SRCS} + APPEND_STRING + PROPERTY COMPILE_FLAGS -Wno-parentheses-equality) endif() -# Arrow -find_package(ArrowPython REQUIRED) -include_directories(SYSTEM ${ARROW_INCLUDE_DIR}) +install(DIRECTORY ${PYARROW_CPP_SOURCE_DIR}/ + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/arrow/python + FILES_MATCHING + PATTERN "*internal.h" EXCLUDE + PATTERN "*.h") function(bundle_arrow_lib library_path) set(options) @@ -252,50 +456,31 @@ function(bundle_arrow_lib library_path) message(SEND_ERROR "Error: unrecognized arguments: ${ARG_UNPARSED_ARGUMENTS}") endif() - get_filename_component(LIBRARY_DIR ${${library_path}} DIRECTORY) - get_filename_component(LIBRARY_NAME ${${library_path}} NAME_WE) + get_filename_component(LIBRARY_PATH_REAL ${library_path} REALPATH) + get_filename_component(LIBRARY_NAME ${library_path} NAME_WE) # Only copy the shared library with ABI version on Linux and macOS if(MSVC) - configure_file(${${library_path}} - ${BUILD_OUTPUT_ROOT_DIRECTORY}/${LIBRARY_NAME}${CMAKE_SHARED_LIBRARY_SUFFIX} - COPYONLY) + install(FILES ${LIBRARY_PATH_REAL} + DESTINATION "." + RENAME ${LIBRARY_NAME}${CMAKE_SHARED_LIBRARY_SUFFIX}) elseif(APPLE) - configure_file(${LIBRARY_DIR}/${LIBRARY_NAME}.${ARG_SO_VERSION}${CMAKE_SHARED_LIBRARY_SUFFIX} - ${BUILD_OUTPUT_ROOT_DIRECTORY}/${LIBRARY_NAME}.${ARG_SO_VERSION}${CMAKE_SHARED_LIBRARY_SUFFIX} - COPYONLY) + install(FILES ${LIBRARY_PATH_REAL} + DESTINATION "." + RENAME ${LIBRARY_NAME}.${ARG_SO_VERSION}${CMAKE_SHARED_LIBRARY_SUFFIX}) else() - configure_file(${LIBRARY_DIR}/${LIBRARY_NAME}${CMAKE_SHARED_LIBRARY_SUFFIX}.${ARG_SO_VERSION} - ${BUILD_OUTPUT_ROOT_DIRECTORY}/${LIBRARY_NAME}${CMAKE_SHARED_LIBRARY_SUFFIX}.${ARG_SO_VERSION} - COPYONLY) + install(FILES ${LIBRARY_PATH_REAL} + DESTINATION "." + RENAME ${LIBRARY_NAME}${CMAKE_SHARED_LIBRARY_SUFFIX}.${ARG_SO_VERSION}) endif() - -endfunction(bundle_arrow_lib) +endfunction() function(bundle_arrow_import_lib library_path) - get_filename_component(LIBRARY_DIR ${${library_path}} DIRECTORY) - get_filename_component(LIBRARY_NAME ${${library_path}} NAME_WE) - configure_file(${${library_path}} ${BUILD_OUTPUT_ROOT_DIRECTORY}/${LIBRARY_NAME}.lib - COPYONLY) -endfunction(bundle_arrow_import_lib) - -function(bundle_boost_lib library_path) - get_filename_component(LIBRARY_NAME ${${library_path}} NAME) - get_filename_component(LIBRARY_NAME_WE ${${library_path}} NAME_WE) - configure_file(${${library_path}} ${BUILD_OUTPUT_ROOT_DIRECTORY}/${LIBRARY_NAME} - COPYONLY) - set(Boost_SO_VERSION - "${Boost_MAJOR_VERSION}.${Boost_MINOR_VERSION}.${Boost_SUBMINOR_VERSION}") - if(APPLE) - configure_file(${${library_path}} - ${BUILD_OUTPUT_ROOT_DIRECTORY}/${LIBRARY_NAME_WE}${CMAKE_SHARED_LIBRARY_SUFFIX} - COPYONLY) - else() - configure_file(${${library_path}} - ${BUILD_OUTPUT_ROOT_DIRECTORY}/${LIBRARY_NAME_WE}${CMAKE_SHARED_LIBRARY_SUFFIX}.${Boost_SO_VERSION} - COPYONLY) - endif() + get_filename_component(LIBRARY_NAME ${library_path} NAME_WE) + install(FILES ${library_path} + DESTINATION "." + RENAME ${LIBRARY_NAME}.lib) endfunction() function(bundle_arrow_dependency library_name) @@ -338,60 +523,25 @@ function(bundle_arrow_dependency library_name) get_filename_component(SHARED_LIB_NAME ${SHARED_LIB_PATH} NAME) message(STATUS "Bundle dependency ${library_name}: ${SHARED_LIB_REALPATH} as ${SHARED_LIB_NAME}" ) - configure_file(${SHARED_LIB_REALPATH} - ${BUILD_OUTPUT_ROOT_DIRECTORY}/${SHARED_LIB_NAME} COPYONLY) + install(FILES ${SHARED_LIB_REALPATH} + DESTINATION "." + RENAME ${SHARED_LIB_NAME}) else() message(FATAL_ERROR "Unable to bundle dependency: ${library_name}") endif() endfunction() # Always bundle includes -get_filename_component(ARROW_INCLUDE_REALPATH "${ARROW_INCLUDE_DIR}/arrow" REALPATH) -file(COPY ${ARROW_INCLUDE_REALPATH} DESTINATION ${BUILD_OUTPUT_ROOT_DIRECTORY}/include) +get_filename_component(ARROW_INCLUDE_DIR_REAL ${ARROW_INCLUDE_DIR} REALPATH) +install(DIRECTORY ${ARROW_INCLUDE_DIR_REAL}/arrow TYPE INCLUDE) if(PYARROW_BUNDLE_ARROW_CPP) - # arrow - bundle_arrow_lib(ARROW_SHARED_LIB SO_VERSION ${ARROW_SO_VERSION}) - bundle_arrow_lib(ARROW_PYTHON_SHARED_LIB SO_VERSION ${ARROW_SO_VERSION}) - - # boost - if(PYARROW_BOOST_USE_SHARED AND PYARROW_BUNDLE_BOOST) - set(Boost_USE_STATIC_LIBS OFF) - set(Boost_USE_MULTITHREADED ON) - if(MSVC AND ARROW_USE_STATIC_CRT) - set(Boost_USE_STATIC_RUNTIME ON) - endif() - set(Boost_ADDITIONAL_VERSIONS - "1.66.0" - "1.66" - "1.65.0" - "1.65" - "1.64.0" - "1.64" - "1.63.0" - "1.63" - "1.62.0" - "1.61" - "1.61.0" - "1.62" - "1.60.0" - "1.60") - list(GET Boost_ADDITIONAL_VERSIONS 0 BOOST_LATEST_VERSION) - string(REPLACE "." "_" BOOST_LATEST_VERSION_IN_PATH ${BOOST_LATEST_VERSION}) - if(MSVC) - # disable autolinking in boost - add_definitions(-DBOOST_ALL_NO_LIB) - endif() - find_package(Boost - COMPONENTS regex - REQUIRED) - bundle_boost_lib(Boost_REGEX_LIBRARY) - endif() + # Arrow + bundle_arrow_lib(${ARROW_SHARED_LIB} SO_VERSION ${ARROW_SO_VERSION}) if(MSVC) # TODO(kszucs): locate msvcp140.dll in a portable fashion and bundle it - bundle_arrow_import_lib(ARROW_IMPORT_LIB) - bundle_arrow_import_lib(ARROW_PYTHON_IMPORT_LIB) + bundle_arrow_import_lib(${ARROW_IMPORT_LIB}) endif() endif() @@ -413,8 +563,9 @@ set(CYTHON_EXTENSIONS _hdfsio _json _pyarrow_cpp_tests) +set_source_files_properties(pyarrow/lib.pyx PROPERTIES CYTHON_API TRUE) -set(LINK_LIBS ArrowPython::arrow_python_shared) +set(LINK_LIBS arrow_python_shared) if(PYARROW_BUILD_GCS) set(CYTHON_EXTENSIONS ${CYTHON_EXTENSIONS} _gcsfs) @@ -430,27 +581,28 @@ endif() if(PYARROW_BUILD_CUDA) # Arrow CUDA + if(NOT ARROW_CUDA) + message(FATAL_ERROR "You must build Arrow C++ with ARROW_CUDA=ON") + endif() find_package(ArrowCUDA REQUIRED) if(PYARROW_BUNDLE_ARROW_CPP) - bundle_arrow_lib(ARROW_CUDA_SHARED_LIB SO_VERSION ${ARROW_SO_VERSION}) + bundle_arrow_lib(${ARROW_CUDA_SHARED_LIB} SO_VERSION ${ARROW_SO_VERSION}) if(MSVC) - bundle_arrow_import_lib(ARROW_CUDA_IMPORT_LIB) + bundle_arrow_import_lib(${ARROW_CUDA_IMPORT_LIB}) endif() endif() set(CUDA_LINK_LIBS ArrowCUDA::arrow_cuda_shared) set(CYTHON_EXTENSIONS ${CYTHON_EXTENSIONS} _cuda) + set_source_files_properties(pyarrow/_cuda.pyx PROPERTIES CYTHON_API TRUE) endif() # Dataset if(PYARROW_BUILD_DATASET) - # Arrow Dataset - find_package(ArrowDataset REQUIRED) - if(PYARROW_BUNDLE_ARROW_CPP) - bundle_arrow_lib(ARROW_DATASET_SHARED_LIB SO_VERSION ${ARROW_SO_VERSION}) + bundle_arrow_lib(${ARROW_DATASET_SHARED_LIB} SO_VERSION ${ARROW_SO_VERSION}) if(MSVC) - bundle_arrow_import_lib(ARROW_DATASET_IMPORT_LIB) + bundle_arrow_import_lib(${ARROW_DATASET_IMPORT_LIB}) endif() endif() @@ -458,38 +610,23 @@ if(PYARROW_BUILD_DATASET) set(CYTHON_EXTENSIONS ${CYTHON_EXTENSIONS} _dataset) endif() +# Parquet if(PYARROW_BUILD_PARQUET) - # Parquet - find_package(Parquet REQUIRED) - - include_directories(SYSTEM ${PARQUET_INCLUDE_DIR}) - if(PYARROW_BUNDLE_ARROW_CPP) - file(COPY ${PARQUET_INCLUDE_DIR}/parquet - DESTINATION ${BUILD_OUTPUT_ROOT_DIRECTORY}/include) + get_filename_component(PARQUET_INCLUDE_DIR_REAL ${PARQUET_INCLUDE_DIR} REALPATH) + install(DIRECTORY ${PARQUET_INCLUDE_DIR_REAL}/parquet TYPE INCLUDE) endif() if(PYARROW_PARQUET_USE_SHARED) if(PYARROW_BUNDLE_ARROW_CPP) - bundle_arrow_lib(PARQUET_SHARED_LIB SO_VERSION ${PARQUET_SO_VERSION}) + bundle_arrow_lib(${PARQUET_SHARED_LIB} SO_VERSION ${PARQUET_SO_VERSION}) if(MSVC) - bundle_arrow_import_lib(PARQUET_IMPORT_LIB) + bundle_arrow_import_lib(${PARQUET_IMPORT_LIB}) endif() endif() set(PARQUET_LINK_LIBS Parquet::parquet_shared) else() - find_package(Thrift) - if(PYARROW_BOOST_USE_SHARED) - set(Boost_USE_STATIC_LIBS OFF) - else() - set(Boost_USE_STATIC_LIBS ON) - endif() - find_package(Boost - COMPONENTS regex - REQUIRED) - add_thirdparty_lib(boost_regex STATIC_LIB ${Boost_REGEX_LIBRARY_RELEASE}) - add_thirdparty_lib(thrift STATIC_LIB ${THRIFT_STATIC_LIB}) - set(PARQUET_LINK_LIBS parquet_static thrift_static boost_regex_static) + set(PARQUET_LINK_LIBS Parquet::parquet_static) endif() set(CYTHON_EXTENSIONS ${CYTHON_EXTENSIONS} _parquet) if(PYARROW_BUILD_PARQUET_ENCRYPTION) @@ -502,23 +639,29 @@ endif() # Plasma if(PYARROW_BUILD_PLASMA) + if(NOT ARROW_PLASMA) + message(FATAL_ERROR "You must build Arrow C++ with ARROW_PLASMA=ON") + endif() find_package(Plasma REQUIRED) - include_directories(SYSTEM ${PLASMA_INCLUDE_DIR}) - - file(COPY ${ARROW_INCLUDE_DIR}/plasma - DESTINATION ${BUILD_OUTPUT_ROOT_DIRECTORY}/include) + get_filename_component(PLASMA_INCLUDE_DIR_REAL ${PLASMA_INCLUDE_DIR} REALPATH) + install(DIRECTORY ${PLASMA_INCLUDE_DIR_REAL}/plasma TYPE INCLUDE) if(PYARROW_BUNDLE_ARROW_CPP) - bundle_arrow_lib(PLASMA_SHARED_LIB SO_VERSION ${PLASMA_SO_VERSION}) + bundle_arrow_lib(${PLASMA_SHARED_LIB} SO_VERSION ${PLASMA_SO_VERSION}) endif() set(PLASMA_LINK_LIBS Plasma::plasma_shared) set(CYTHON_EXTENSIONS ${CYTHON_EXTENSIONS} _plasma) - file(COPY ${PLASMA_STORE_SERVER} DESTINATION ${BUILD_OUTPUT_ROOT_DIRECTORY}) + if(PYARROW_BUNDLE_PLASMA_EXECUTABLE) + install(PROGRAMS ${PLASMA_STORE_SERVER} DESTINATION ".") + endif() endif() if(PYARROW_BUILD_ORC) # ORC + if(NOT ARROW_ORC) + message(FATAL_ERROR "You must build Arrow C++ with ARROW_ORC=ON") + endif() set(CYTHON_EXTENSIONS ${CYTHON_EXTENSIONS} _orc) if(PYARROW_BUILD_DATASET) set(CYTHON_EXTENSIONS ${CYTHON_EXTENSIONS} _dataset_orc) @@ -527,15 +670,10 @@ endif() # Flight if(PYARROW_BUILD_FLIGHT) - # Arrow Flight - find_package(ArrowPythonFlight REQUIRED) - if(PYARROW_BUNDLE_ARROW_CPP) - bundle_arrow_lib(ARROW_FLIGHT_SHARED_LIB SO_VERSION ${ARROW_SO_VERSION}) - bundle_arrow_lib(ARROW_PYTHON_FLIGHT_SHARED_LIB SO_VERSION ${ARROW_SO_VERSION}) + bundle_arrow_lib(${ARROW_FLIGHT_SHARED_LIB} SO_VERSION ${ARROW_SO_VERSION}) if(MSVC) - bundle_arrow_import_lib(ARROW_FLIGHT_IMPORT_LIB) - bundle_arrow_import_lib(ARROW_PYTHON_FLIGHT_IMPORT_LIB) + bundle_arrow_import_lib(${ARROW_FLIGHT_IMPORT_LIB}) # XXX Hardcoded library names because CMake is too stupid to give us # the shared library paths. # https://gitlab.kitware.com/cmake/cmake/issues/16210 @@ -544,17 +682,20 @@ if(PYARROW_BUILD_FLIGHT) endif() endif() - set(FLIGHT_LINK_LIBS ArrowPythonFlight::arrow_python_flight_shared) + set(FLIGHT_LINK_LIBS arrow_python_flight_shared) set(CYTHON_EXTENSIONS ${CYTHON_EXTENSIONS} _flight) endif() -# Engine +# Substrait if(PYARROW_BUILD_SUBSTRAIT) + if(NOT ARROW_SUBSTRAIT) + message(FATAL_ERROR "You must build Arrow C++ with ARROW_SUBSTRAIT=ON") + endif() find_package(ArrowSubstrait REQUIRED) if(PYARROW_BUNDLE_ARROW_CPP) - bundle_arrow_lib(ARROW_SUBSTRAIT_SHARED_LIB SO_VERSION ${ARROW_SO_VERSION}) + bundle_arrow_lib(${ARROW_SUBSTRAIT_SHARED_LIB} SO_VERSION ${ARROW_SO_VERSION}) if(MSVC) - bundle_arrow_import_lib(ARROW_SUBSTRAIT_IMPORT_LIB) + bundle_arrow_import_lib(${ARROW_SUBSTRAIT_IMPORT_LIB}) endif() endif() @@ -564,18 +705,19 @@ endif() # Gandiva if(PYARROW_BUILD_GANDIVA) + if(NOT ARROW_GANDIVA) + message(FATAL_ERROR "You must build Arrow C++ with ARROW_GANDIVA=ON") + endif() find_package(Gandiva REQUIRED) - include_directories(SYSTEM ${GANDIVA_INCLUDE_DIR}) - if(PYARROW_BUNDLE_ARROW_CPP) - file(COPY ${GANDIVA_INCLUDE_DIR}/gandiva - DESTINATION ${BUILD_OUTPUT_ROOT_DIRECTORY}/include) + get_filename_component(GANDIVA_INCLUDE_DIR_REAL ${GANDIVA_INCLUDE_DIR} REALPATH) + install(DIRECTORY ${GANDIVA_INCLUDE_DIR_REAL}/gandiva TYPE INCLUDE) - bundle_arrow_lib(GANDIVA_SHARED_LIB SO_VERSION ${ARROW_SO_VERSION}) + bundle_arrow_lib(${GANDIVA_SHARED_LIB} SO_VERSION ${ARROW_SO_VERSION}) if(MSVC) - bundle_arrow_import_lib(GANDIVA_IMPORT_LIB) + bundle_arrow_import_lib(${GANDIVA_IMPORT_LIB}) endif() endif() @@ -601,7 +743,7 @@ foreach(module ${CYTHON_EXTENSIONS}) string(REPLACE "." "/" module_root "${module}") set(module_SRC pyarrow/${module_root}.pyx) - set_source_files_properties(${module_SRC} PROPERTIES CYTHON_IS_CXX 1) + set_source_files_properties(${module_SRC} PROPERTIES CYTHON_IS_CXX TRUE) cython_add_module(${module_name} ${module_name}_pyx ${module_name}_output ${module_SRC}) @@ -640,8 +782,16 @@ foreach(module ${CYTHON_EXTENSIONS}) target_link_libraries(${module_name} PRIVATE ${LINK_LIBS}) - # Generated files will be moved to the right directory by setup.py. -endforeach(module) + install(TARGETS ${module_name} LIBRARY DESTINATION ".") + foreach(output ${${module_name}_output}) + if(output MATCHES "\\.${CYTHON_CXX_EXTENSION}$") + if(NOT PYARROW_BUNDLE_CYTHON_CPP) + continue() + endif() + endif() + install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${output} DESTINATION ".") + endforeach() +endforeach() # Additional link libraries diff --git a/python/pyarrow/src/ArrowPythonConfig.cmake.in b/python/pyarrow/src/ArrowPythonConfig.cmake.in deleted file mode 100644 index 874c5cc09d1..00000000000 --- a/python/pyarrow/src/ArrowPythonConfig.cmake.in +++ /dev/null @@ -1,41 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one -# or more contributor license agreements. See the NOTICE file -# distributed with this work for additional information -# regarding copyright ownership. The ASF licenses this file -# to you under the Apache License, Version 2.0 (the -# "License"); you may not use this file except in compliance -# with the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an -# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -# KIND, either express or implied. See the License for the -# specific language governing permissions and limitations -# under the License. -# -# This config sets the following variables in your project:: -# -# ArrowPython_FOUND - true if Arrow Python found on the system -# -# This config sets the following targets in your project:: -# -# ArrowPython::arrow_python_shared - for linked as shared library if shared library is built -# ArrowPython::arrow_python_static - for linked as static library if static library is built - -@PACKAGE_INIT@ - -include(CMakeFindDependencyMacro) -find_dependency(Arrow) -if(PARQUET_REQUIRE_ENCRYPTION) - find_dependency(Parquet) -endif() - -include("${CMAKE_CURRENT_LIST_DIR}/ArrowPythonTargets.cmake") - -arrow_keep_backward_compatibility(ArrowPython arrow_python) - -check_required_components(ArrowPython) - -arrow_show_details(ArrowPython ARROW_PYTHON) diff --git a/python/pyarrow/src/ArrowPythonFlightConfig.cmake.in b/python/pyarrow/src/ArrowPythonFlightConfig.cmake.in deleted file mode 100644 index 1aacb9f212d..00000000000 --- a/python/pyarrow/src/ArrowPythonFlightConfig.cmake.in +++ /dev/null @@ -1,39 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one -# or more contributor license agreements. See the NOTICE file -# distributed with this work for additional information -# regarding copyright ownership. The ASF licenses this file -# to you under the Apache License, Version 2.0 (the -# "License"); you may not use this file except in compliance -# with the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an -# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -# KIND, either express or implied. See the License for the -# specific language governing permissions and limitations -# under the License. -# -# This config sets the following variables in your project:: -# -# ArrowPythonFlight_FOUND - true if Arrow Python Flight found on the system -# -# This config sets the following targets in your project:: -# -# ArrowPythonFlight::arrow_python_flight_shared - for linked as shared library if shared library is built -# ArrowPythonFlight::arrow_python_flight_static - for linked as static library if static library is built - -@PACKAGE_INIT@ - -include(CMakeFindDependencyMacro) -find_dependency(ArrowFlight) -find_dependency(ArrowPython) - -include("${CMAKE_CURRENT_LIST_DIR}/ArrowPythonFlightTargets.cmake") - -arrow_keep_backward_compatibility(ArrowPythonFlight arrow_python_flight) - -check_required_components(ArrowPythonFlight) - -arrow_show_details(ArrowPythonFlight ARROW_PYTHON_FLIGHT) diff --git a/python/pyarrow/src/CMakeLists.txt b/python/pyarrow/src/CMakeLists.txt deleted file mode 100644 index 87a106c594a..00000000000 --- a/python/pyarrow/src/CMakeLists.txt +++ /dev/null @@ -1,312 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one -# or more contributor license agreements. See the NOTICE file -# distributed with this work for additional information -# regarding copyright ownership. The ASF licenses this file -# to you under the Apache License, Version 2.0 (the -# "License"); you may not use this file except in compliance -# with the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an -# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -# KIND, either express or implied. See the License for the -# specific language governing permissions and limitations -# under the License. - -# -# arrow_python -# - -cmake_minimum_required(VERSION 3.5) - -# RPATH settings on macOS do not affect install_name. -# https://cmake.org/cmake/help/latest/policy/CMP0068.html -if(POLICY CMP0068) - cmake_policy(SET CMP0068 NEW) -endif() - -# -# Define -# CMAKE_MODULE_PATH: location of cmake_modules in python -# - -get_filename_component(PYARROW_SOURCE_DIR ${CMAKE_SOURCE_DIR} DIRECTORY) -get_filename_component(PYTHON_SOURCE_DIR ${PYARROW_SOURCE_DIR} DIRECTORY) -get_filename_component(ARROW_SOURCE_DIR ${PYTHON_SOURCE_DIR} DIRECTORY) -set(ARROW_CPP_SOURCE_DIR "${ARROW_SOURCE_DIR}/cpp") - -set(CMAKE_MODULE_PATH "${PYTHON_SOURCE_DIR}/cmake_modules") - -# normalize ARROW_HOME path -file(TO_CMAKE_PATH "$ENV{ARROW_HOME}" ARROW_HOME) -list(INSERT CMAKE_PREFIX_PATH 0 "${ARROW_HOME}") - -# -# Arrow version -# - -set(ARROW_PYTHON_VERSION "11.0.0-SNAPSHOT") -string(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" ARROW_PYTHON_BASE_VERSION "${ARROW_PYTHON_VERSION}") -# Need to set to ARRROW_VERSION before finding Arrow package! -project(arrow_python VERSION "${ARROW_PYTHON_BASE_VERSION}") - -if(NOT DEFINED CMAKE_BUILD_TYPE) - set(CMAKE_BUILD_TYPE Release) -endif() - -# -# Arrow -# - -find_package(Arrow REQUIRED) - -# -# Python -# -# Use the first Python installation on PATH, not the newest one -set(Python3_FIND_STRATEGY "LOCATION") -# On Windows, use registry last, not first -set(Python3_FIND_REGISTRY "LAST") -# On macOS, use framework last, not first -set(Python3_FIND_FRAMEWORK "LAST") - -find_package(Python3Alt 3.7 REQUIRED) -include_directories(SYSTEM ${NUMPY_INCLUDE_DIRS} ${PYTHON_INCLUDE_DIRS} ${ARROW_INCLUDE_DIR} ${CMAKE_SOURCE_DIR} src) - -add_custom_target(arrow_python) - -set(ARROW_PYTHON_SRCS - arrow/python/arrow_to_pandas.cc - arrow/python/benchmark.cc - arrow/python/common.cc - arrow/python/datetime.cc - arrow/python/decimal.cc - arrow/python/deserialize.cc - arrow/python/extension_type.cc - arrow/python/gdb.cc - arrow/python/helpers.cc - arrow/python/inference.cc - arrow/python/init.cc - arrow/python/io.cc - arrow/python/ipc.cc - arrow/python/numpy_convert.cc - arrow/python/numpy_to_arrow.cc - arrow/python/python_test.cc - arrow/python/python_to_arrow.cc - arrow/python/pyarrow.cc - arrow/python/serialize.cc - arrow/python/udf.cc) - -set_source_files_properties(init.cc PROPERTIES SKIP_PRECOMPILE_HEADERS ON - SKIP_UNITY_BUILD_INCLUSION ON) - -# -# Shared/static link libs -# - -set(ARROW_PYTHON_SHARED_LINK_LIBS) -set(ARROW_PYTHON_SHARED_PRIVATE_LINK_LIBS) -set(ARROW_PYTHON_SHARED_INSTALL_INTERFACE_LIBS) -set(ARROW_PYTHON_STATIC_LINK_LIBS) -set(ARROW_PYTHON_STATIC_INSTALL_INTERFACE_LIBS) - -# -# Arrow vs PyArrow C++ options -# - -# Check all the options from Arrow and PyArrow C++ to be in line -if(PYARROW_WITH_DATASET) - find_package(ArrowDataset REQUIRED) - list(APPEND ARROW_PYTHON_SHARED_LINK_LIBS ArrowDataset::arrow_dataset_shared) - list(APPEND ARROW_PYTHON_SHARED_INSTALL_INTERFACE_LIBS ArrowDataset::arrow_dataset_shared) - list(APPEND ARROW_PYTHON_STATIC_LINK_LIBS ArrowDataset::arrow_dataset_static) - list(APPEND ARROW_PYTHON_STATIC_INSTALL_INTERFACE_LIBS ArrowDataset::arrow_dataset_static) -endif() - -if(PYARROW_WITH_PARQUET_ENCRYPTION) - if(PARQUET_REQUIRE_ENCRYPTION) - list(APPEND ARROW_PYTHON_SRCS arrow/python/parquet_encryption.cc) - find_package(Parquet REQUIRED) - list(APPEND ARROW_PYTHON_SHARED_LINK_LIBS Parquet::parquet_shared) - list(APPEND ARROW_PYTHON_SHARED_INSTALL_INTERFACE_LIBS Parquet::parquet_shared) - list(APPEND ARROW_PYTHON_STATIC_LINK_LIBS Parquet::parquet_static) - list(APPEND ARROW_PYTHON_STATIC_INSTALL_INTERFACE_LIBS Parquet::parquet_static) - else() - message(FATAL_ERROR "You must build Arrow C++ with PARQUET_REQUIRE_ENCRYPTION=ON") - endif() -endif() - -if(PYARROW_WITH_HDFS) - if(NOT ARROW_HDFS) - message(FATAL_ERROR "You must build Arrow C++ with ARROW_HDFS=ON") - endif() -endif() - -# Check for only Arrow C++ options -if(ARROW_CSV) - list(APPEND ARROW_PYTHON_SRCS arrow/python/csv.cc) -endif() - -if(ARROW_FILESYSTEM) - list(APPEND ARROW_PYTHON_SRCS arrow/python/filesystem.cc) -endif() - -if(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang") - set_property(SOURCE pyarrow.cc - APPEND_STRING - PROPERTY COMPILE_FLAGS " -Wno-cast-qual ") -endif() - -if(NOT ARROW_PYTHON_SHARED_LINK_LIBS) - list(APPEND ARROW_PYTHON_SHARED_LINK_LIBS Arrow::arrow_shared) -endif() -if(NOT ARROW_PYTHON_SHARED_INSTALL_INTERFACE_LIBS) - list(APPEND ARROW_PYTHON_SHARED_INSTALL_INTERFACE_LIBS Arrow::arrow_shared) -endif() -if(NOT ARROW_PYTHON_STATIC_LINK_LIBS) - list(APPEND ARROW_PYTHON_STATIC_LINK_LIBS Arrow::arrow_static) -endif() -list(APPEND ARROW_PYTHON_STATIC_LINK_LIBS ${PYTHON_OTHER_LIBS}) -if(NOT ARROW_PYTHON_STATIC_INSTALL_INTERFACE_LIBS) - list(APPEND ARROW_PYTHON_STATIC_INSTALL_INTERFACE_LIBS Arrow::arrow_static) -endif() - -if(WIN32) - list(APPEND ARROW_PYTHON_SHARED_LINK_LIBS ${PYTHON_LIBRARIES} ${PYTHON_OTHER_LIBS}) -endif() - -# -# Compiler stuff -# - -include(GNUInstallDirs) - -# This ensures that things like -std=gnu++... get passed correctly -if(NOT DEFINED CMAKE_CXX_STANDARD) - set(CMAKE_CXX_STANDARD 17) -endif() - -# We require a C++17 compliant compiler -set(CMAKE_CXX_STANDARD_REQUIRED ON) - -# Needed compiler flags -include(SetupCxxFlags) - -# Add common flags -set(CMAKE_CXX_FLAGS "${CXX_COMMON_FLAGS} ${CMAKE_CXX_FLAGS}") -set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${PYARROW_CXXFLAGS}") - -message(STATUS "CMAKE_C_FLAGS: ${CMAKE_C_FLAGS}") -message(STATUS "CMAKE_CXX_FLAGS: ${CMAKE_CXX_FLAGS}") - -set(ARROW_PYTHON_INCLUDES ${NUMPY_INCLUDE_DIRS} ${PYTHON_INCLUDE_DIRS}) - -# Inlude macros needed to find and use add_arrow_lib function -include(BuildUtils) -include(CMakePackageConfigHelpers) - -# Set the output directory for CMake files -# (CMAKE_INSTALL_PREFIX = python/build/dist! should be set in setup.py!) -set(ARROW_CMAKE_DIR "${CMAKE_INSTALL_LIBDIR}/cmake") - -# Changing ARROW_SOURCE_DIR for sdist build -# In this case cpp/cmake_modules doesn't exist -if(NOT EXISTS "${ARROW_SOURCE_DIR}/cpp/cmake_modules") - set(ARROW_SOURCE_DIR ${PYTHON_SOURCE_DIR}) -endif() - -add_arrow_lib(arrow_python - CMAKE_PACKAGE_NAME - ArrowPython - PKG_CONFIG_NAME - arrow-python - SOURCES - ${ARROW_PYTHON_SRCS} - PRECOMPILED_HEADERS - "$<$:arrow/python/pch.h>" - OUTPUTS - ARROW_PYTHON_LIBRARIES - SHARED_LINK_FLAGS - ${ARROW_VERSION_SCRIPT_FLAGS} - SHARED_LINK_LIBS - ${ARROW_PYTHON_SHARED_LINK_LIBS} - SHARED_PRIVATE_LINK_LIBS - ${ARROW_PYTHON_SHARED_PRIVATE_LINK_LIBS} - SHARED_INSTALL_INTERFACE_LIBS - ${ARROW_PYTHON_SHARED_INSTALL_INTERFACE_LIBS} - STATIC_LINK_LIBS - ${ARROW_PYTHON_STATIC_LINK_LIBS} - STATIC_INSTALL_INTERFACE_LIBS - ${ARROW_PYTHON_STATIC_INSTALL_INTERFACE_LIBS} - EXTRA_INCLUDES - "${ARROW_PYTHON_INCLUDES}") - -add_dependencies(arrow_python ${ARROW_PYTHON_LIBRARIES}) - -foreach(LIB_TARGET ${ARROW_PYTHON_LIBRARIES}) - target_compile_definitions(${LIB_TARGET} PRIVATE ARROW_PYTHON_EXPORTING) -endforeach() - -if(ARROW_BUILD_STATIC AND MSVC) - target_compile_definitions(arrow_python_static PUBLIC ARROW_STATIC) -endif() - -if(PYARROW_WITH_FLIGHT AND ARROW_FLIGHT AND ARROW_BUILD_SHARED) - # Must link to shared libarrow_flight: we don't want to link more than one - # copy of gRPC into the eventual Cython shared object, otherwise gRPC calls - # fail with weird errors due to multiple copies of global static state (The - # other solution is to link gRPC shared everywhere instead of statically only - # in Flight) - find_package(ArrowFlight REQUIRED) - - set(FLIGHT_LINK_LIBS ArrowFlight::arrow_flight_shared) - - add_arrow_lib(arrow_python_flight - CMAKE_PACKAGE_NAME - ArrowPythonFlight - PKG_CONFIG_NAME - arrow-python-flight - SOURCES - arrow/python/flight.cc - OUTPUTS - ARROW_PYFLIGHT_LIBRARIES - SHARED_LINK_FLAGS - ${ARROW_VERSION_SCRIPT_FLAGS} - SHARED_LINK_LIBS - arrow_python_shared - ArrowFlight::arrow_flight_shared - SHARED_INSTALL_INTERFACE_LIBS - ArrowPython::arrow_python_shared - ArrowFlight::arrow_flight_shared - STATIC_LINK_LIBS - arrow_python_static - ArrowFlight::arrow_flight_static - STATIC_INSTALL_INTERFACE_LIBS - ArrowPython::arrow_python_static - ArrowFlight::arrow_flight_static - EXTRA_INCLUDES - "${ARROW_PYTHON_INCLUDES}" - PRIVATE_INCLUDES - "${Protobuf_INCLUDE_DIRS}") - - add_dependencies(arrow_python ${ARROW_PYFLIGHT_LIBRARIES}) - - foreach(LIB_TARGET ${ARROW_PYFLIGHT_LIBRARIES}) - target_compile_definitions(${LIB_TARGET} PRIVATE ARROW_PYFLIGHT_EXPORTING) - endforeach() - - if(ARROW_BUILD_STATIC AND MSVC) - target_compile_definitions(arrow_python_flight_static PUBLIC ARROW_PYTHON_STATIC) - endif() -endif() - -if(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang") - # Clang, be quiet. Python C API has lots of macros - set_property(SOURCE ${ARROW_PYTHON_SRCS} - APPEND_STRING - PROPERTY COMPILE_FLAGS -Wno-parentheses-equality) -endif() - -add_subdirectory(arrow/python) diff --git a/python/pyarrow/src/arrow-python-flight.pc.in b/python/pyarrow/src/arrow-python-flight.pc.in deleted file mode 100644 index a98ad1fbf6c..00000000000 --- a/python/pyarrow/src/arrow-python-flight.pc.in +++ /dev/null @@ -1,26 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one -# or more contributor license agreements. See the NOTICE file -# distributed with this work for additional information -# regarding copyright ownership. The ASF licenses this file -# to you under the Apache License, Version 2.0 (the -# "License"); you may not use this file except in compliance -# with the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an -# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -# KIND, either express or implied. See the License for the -# specific language governing permissions and limitations -# under the License. - -prefix=@CMAKE_INSTALL_PREFIX@ -includedir=@ARROW_PKG_CONFIG_INCLUDEDIR@ -libdir=@ARROW_PKG_CONFIG_LIBDIR@ - -Name: Apache Arrow Python Flight -Description: Python integration library for Apache Arrow Flight -Version: @ARROW_VERSION@ -Requires: arrow-python arrow-flight -Libs: -L${libdir} -larrow_python_flight diff --git a/python/pyarrow/src/arrow-python.pc.in b/python/pyarrow/src/arrow-python.pc.in deleted file mode 100644 index 0efd0ad9830..00000000000 --- a/python/pyarrow/src/arrow-python.pc.in +++ /dev/null @@ -1,28 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one -# or more contributor license agreements. See the NOTICE file -# distributed with this work for additional information -# regarding copyright ownership. The ASF licenses this file -# to you under the Apache License, Version 2.0 (the -# "License"); you may not use this file except in compliance -# with the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an -# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -# KIND, either express or implied. See the License for the -# specific language governing permissions and limitations -# under the License. - -prefix=@CMAKE_INSTALL_PREFIX@ -includedir=@ARROW_PKG_CONFIG_INCLUDEDIR@ -libdir=@ARROW_PKG_CONFIG_LIBDIR@ - -Name: Apache Arrow Python -Description: Python integration library for Apache Arrow -Version: @ARROW_VERSION@ -Requires: arrow -Libs: -L${libdir} -larrow_python -Cflags: -I${includedir} -I@PYTHON_INCLUDE_DIRS@ -Cflags.private: -DARROW_PYTHON_STATIC diff --git a/python/setup.py b/python/setup.py index bb9abcbd374..2e184e6411a 100755 --- a/python/setup.py +++ b/python/setup.py @@ -18,13 +18,11 @@ # under the License. import contextlib -import glob import os import os.path from os.path import join as pjoin import re import shlex -import shutil import sys if sys.version_info >= (3, 10): @@ -93,9 +91,7 @@ def build_extensions(self): _build_ext.build_extensions(self) def run(self): - pyarrow_cpp_home = pjoin(os.getcwd(), 'build', 'dist') - self._run_cmake_pyarrow_cpp(pyarrow_cpp_home) - self._run_cmake(pyarrow_cpp_home) + self._run_cmake() _build_ext.run(self) # adapted from cmake_build_ext in dynd-python @@ -230,74 +226,7 @@ def initialize_options(self): '_hdfsio', 'gandiva'] - def _run_cmake_pyarrow_cpp(self, pyarrow_cpp_home): - # check if build_type is correctly passed / set - if self.build_type.lower() not in ('release', 'debug', - 'relwithdebinfo'): - raise ValueError("--build-type (or PYARROW_BUILD_TYPE) needs to " - "be 'release', 'debug' or 'relwithdebinfo'") - - # The directory containing this setup.py - source = os.path.dirname(os.path.abspath(__file__)) - # The directory containing this PyArrow C++ CMakeLists.txt - source_pyarrow_cpp = pjoin(source, "pyarrow/src") - - # The directory for the module being built - build_dir = pjoin(os.getcwd(), 'build', 'cpp') - - if not os.path.isdir(build_dir): - self.mkpath(build_dir) - - # Change to the build directory - with changed_dir(build_dir): - # cmake args - cmake_options = [ - '-DCMAKE_BUILD_TYPE=' + str(self.build_type.lower()), - '-DCMAKE_INSTALL_LIBDIR=lib', - '-DCMAKE_INSTALL_PREFIX=' + str(pyarrow_cpp_home), - '-DPYTHON_EXECUTABLE=' + sys.executable, - '-DPython3_EXECUTABLE=' + sys.executable, - '-DPYARROW_CXXFLAGS=' + str(self.cmake_cxxflags), - ] - - # Check for specific options - def append_cmake_bool(value, varname): - cmake_options.append('-D{0}={1}'.format( - varname, 'on' if value else 'off')) - - append_cmake_bool(self.with_dataset, 'PYARROW_WITH_DATASET') - append_cmake_bool(self.with_parquet_encryption, - 'PYARROW_WITH_PARQUET_ENCRYPTION') - append_cmake_bool(self.with_hdfs, - 'PYARROW_WITH_HDFS') - append_cmake_bool(self.with_flight, - 'PYARROW_WITH_FLIGHT') - - # Windows - if self.cmake_generator: - cmake_options += ['-G', self.cmake_generator] - - # build args - build_tool_args = [] - if os.environ.get('PYARROW_BUILD_VERBOSE', '0') == '1': - cmake_options.append('-DCMAKE_VERBOSE_MAKEFILE=ON') - if os.environ.get('PYARROW_PARALLEL'): - build_tool_args.append('--') - build_tool_args.append( - '-j{0}'.format(os.environ['PYARROW_PARALLEL'])) - - # run cmake - print("-- Running CMake for PyArrow C++") - self.spawn(['cmake'] + cmake_options + [source_pyarrow_cpp]) - print("-- Finished CMake for PyArrow C++") - # run make & install - print("-- Running CMake build and install for PyArrow C++") - self.spawn(['cmake', '--build', '.', '--config', - self.build_type, '--target', 'install'] + - build_tool_args) - print("-- Finished CMake build and install for PyArrow C++") - - def _run_cmake(self, pyarrow_cpp_home): + def _run_cmake(self): # check if build_type is correctly passed / set if self.build_type.lower() not in ('release', 'debug', 'relwithdebinfo'): @@ -320,6 +249,8 @@ def _run_cmake(self, pyarrow_cpp_home): # a bit hacky build_lib = saved_cwd + install_prefix = pjoin(build_lib, "pyarrow") + # Change to the build directory with changed_dir(build_temp): # Detect if we built elsewhere @@ -336,14 +267,11 @@ def _run_cmake(self, pyarrow_cpp_home): f"{build_base}.") return - static_lib_option = '' - cmake_options = [ - '-DPYTHON_EXECUTABLE=' + sys.executable, - '-DPython3_EXECUTABLE=' + sys.executable, - '-DPYARROW_CPP_HOME=' + str(pyarrow_cpp_home), - '-DPYARROW_CXXFLAGS=' + str(self.cmake_cxxflags), - static_lib_option, + f'-DCMAKE_INSTALL_PREFIX={install_prefix}', + f'-DPYTHON_EXECUTABLE={sys.executable}', + f'-DPython3_EXECUTABLE={sys.executable}', + f'-DPYARROW_CXXFLAGS={self.cmake_cxxflags}', ] def append_cmake_bool(value, varname): @@ -371,6 +299,10 @@ def append_cmake_bool(value, varname): 'PYARROW_BUNDLE_ARROW_CPP') append_cmake_bool(self.bundle_boost, 'PYARROW_BUNDLE_BOOST') + append_cmake_bool(self.bundle_cython_cpp, + 'PYARROW_BUNDLE_CYTHON_CPP') + append_cmake_bool(self.bundle_plasma_executable, + 'PYARROW_BUNDLE_PLASMA_EXECUTABLE') append_cmake_bool(self.generate_coverage, 'PYARROW_GENERATE_COVERAGE') append_cmake_bool(not self.with_static_boost, @@ -378,12 +310,12 @@ def append_cmake_bool(value, varname): append_cmake_bool(not self.with_static_parquet, 'PYARROW_PARQUET_USE_SHARED') - cmake_options.append('-DCMAKE_BUILD_TYPE={0}' - .format(self.build_type.lower())) + cmake_options.append( + f'-DCMAKE_BUILD_TYPE={self.build_type.lower()}') if self.boost_namespace != 'boost': - cmake_options.append('-DBoost_NAMESPACE={}' - .format(self.boost_namespace)) + cmake_options.append( + f'-DBoost_NAMESPACE={self.boost_namespace}') extra_cmake_args = shlex.split(self.extra_cmake_args) @@ -395,9 +327,9 @@ def append_cmake_bool(value, varname): build_tool_args.append('--') if os.environ.get('PYARROW_BUILD_VERBOSE', '0') == '1': cmake_options.append('-DCMAKE_VERBOSE_MAKEFILE=ON') - if os.environ.get('PYARROW_PARALLEL'): - build_tool_args.append( - '-j{0}'.format(os.environ['PYARROW_PARALLEL'])) + parallel = os.environ.get('PYARROW_PARALLEL') + if parallel: + build_tool_args.append(f'-j{parallel}') # Generate the build files print("-- Running cmake for PyArrow") @@ -409,137 +341,24 @@ def append_cmake_bool(value, varname): build_tool_args) print("-- Finished cmake --build for PyArrow") - # Move the libraries to the place expected by the Python build - try: - os.makedirs(pjoin(build_lib, 'pyarrow')) - except OSError: - pass - - def copy_libs(dir): - for path in os.listdir(pjoin(pyarrow_cpp_home, dir)): - if "python" in path: - pyarrow_path = pjoin(build_lib, "pyarrow", path) - if os.path.exists(pyarrow_path): - os.remove(pyarrow_path) - pyarrow_cpp_path = pjoin(pyarrow_cpp_home, dir, path) - print(f"Copying {pyarrow_cpp_path} to {pyarrow_path}") - shutil.copy(pyarrow_cpp_path, pyarrow_path) - - # Move libraries to python/pyarrow - # For windows builds, move DLL from bin/ - try: - copy_libs("bin") - except OSError: - pass - copy_libs("lib") + print("-- Running cmake --build --target install for PyArrow") + self.spawn(['cmake', '--build', '.', '--config', self.build_type] + + ['--target', 'install'] + build_tool_args) + print("-- Finished cmake --build --target install for PyArrow") - if sys.platform == 'win32': - build_prefix = '' - else: - build_prefix = self.build_type - - pyarrow_include = pjoin(build_lib, 'pyarrow', 'include') - # Move Arrow C++ headers to pyarrow/include - if self.bundle_arrow_cpp or self.bundle_arrow_cpp_headers: - arrow_cpp_include = pjoin(build_prefix, 'include') - print('Bundling includes: ' + arrow_cpp_include) - if os.path.exists(pyarrow_include): - shutil.rmtree(pyarrow_include) - shutil.move(arrow_cpp_include, pyarrow_include) - - # Move PyArrow headers to pyarrow/include - pyarrow_cpp_include = pjoin(pyarrow_cpp_home, 'include') - pyarrow_include_sub = pjoin(pyarrow_include, 'arrow', 'python') - print('Moving PyArrow C++ includes: ' + pyarrow_include_sub) - if os.path.exists(pyarrow_include_sub): - shutil.rmtree(pyarrow_include_sub) - shutil.move(pjoin(pyarrow_cpp_include, 'arrow', 'python'), - pyarrow_include_sub) - - # Move the built C-extension to the place expected by the Python - # build self._found_names = [] for name in self.CYTHON_MODULE_NAMES: - built_path = self.get_ext_built(name) + built_path = pjoin(install_prefix, name + ext_suffix) if not os.path.exists(built_path): - print('Did not find {0}'.format(built_path)) + print(f'Did not find {built_path}') if self._failure_permitted(name): - print('Cython module {0} failure permitted' - .format(name)) + print(f'Cython module {name} failure permitted') continue raise RuntimeError('PyArrow C-extension failed to build:', os.path.abspath(built_path)) - # The destination path to move the built C extension to - ext_path = pjoin(build_lib, self._get_cmake_ext_path(name)) - if os.path.exists(ext_path): - os.remove(ext_path) - self.mkpath(os.path.dirname(ext_path)) - - if self.bundle_cython_cpp: - self._bundle_cython_cpp(name, build_lib) - - print('Moving built C-extension', built_path, - 'to build path', ext_path) - shutil.move(built_path, ext_path) self._found_names.append(name) - if os.path.exists(self.get_ext_built_api_header(name)): - shutil.move(self.get_ext_built_api_header(name), - pjoin(os.path.dirname(ext_path), - name + '_api.h')) - - if self.bundle_arrow_cpp: - self._bundle_arrow_cpp(build_prefix, build_lib) - - if self.with_plasma and self.bundle_plasma_executable: - # Move the plasma store - source = os.path.join(self.build_type, "plasma-store-server") - target = os.path.join(build_lib, - self._get_build_dir(), - "plasma-store-server") - shutil.move(source, target) - - def _bundle_arrow_cpp(self, build_prefix, build_lib): - print(pjoin(build_lib, 'pyarrow')) - move_shared_libs(build_prefix, build_lib, "arrow") - move_shared_libs(build_prefix, build_lib, "arrow_python") - if self.with_cuda: - move_shared_libs(build_prefix, build_lib, "arrow_cuda") - if self.with_substrait: - move_shared_libs(build_prefix, build_lib, "arrow_substrait") - if self.with_flight: - move_shared_libs(build_prefix, build_lib, "arrow_flight") - if self.with_dataset: - move_shared_libs(build_prefix, build_lib, "arrow_dataset") - if self.with_plasma: - move_shared_libs(build_prefix, build_lib, "plasma") - if self.with_gandiva: - move_shared_libs(build_prefix, build_lib, "gandiva") - if self.with_parquet and not self.with_static_parquet: - move_shared_libs(build_prefix, build_lib, "parquet") - if not self.with_static_boost and self.bundle_boost: - move_shared_libs( - build_prefix, build_lib, - "{}_regex".format(self.boost_namespace), - implib_required=False) - - def _bundle_cython_cpp(self, name, lib_path): - cpp_generated_path = self.get_ext_generated_cpp_source(name) - if not os.path.exists(cpp_generated_path): - raise RuntimeError('expected to find generated C++ file ' - 'in {0!r}'.format(cpp_generated_path)) - - # The destination path to move the generated C++ source to - # (for Cython source coverage) - cpp_path = pjoin(lib_path, self._get_build_dir(), - os.path.basename(cpp_generated_path)) - if os.path.exists(cpp_path): - os.remove(cpp_path) - print('Moving generated C++ source', cpp_generated_path, - 'to build path', cpp_path) - shutil.move(cpp_generated_path, cpp_path) - def _failure_permitted(self, name): if name == '_parquet' and not self.with_parquet: return True @@ -599,18 +418,6 @@ def get_ext_built_api_header(self, name): else: return pjoin(name + "_api.h") - def get_ext_built(self, name): - if sys.platform == 'win32': - head, tail = os.path.split(name) - # Visual Studio seems to differ from other generators in - # where it places output files. - if self.cmake_generator.startswith('Visual Studio'): - return pjoin(head, self.build_type, tail + ext_suffix) - else: - return pjoin(head, tail + ext_suffix) - else: - return pjoin(self.build_type, name + ext_suffix) - def get_names(self): return self._found_names @@ -621,50 +428,6 @@ def get_outputs(self): for name in self.get_names()] -def move_shared_libs(build_prefix, build_lib, lib_name, - implib_required=True): - if sys.platform == 'win32': - # Move all .dll and .lib files - libs = [lib_name + '.dll'] - if implib_required: - libs.append(lib_name + '.lib') - for filename in libs: - shutil.move(pjoin(build_prefix, filename), - pjoin(build_lib, 'pyarrow', filename)) - else: - _move_shared_libs_unix(build_prefix, build_lib, lib_name) - - -def _move_shared_libs_unix(build_prefix, build_lib, lib_name): - shared_library_prefix = 'lib' - if sys.platform == 'darwin': - shared_library_suffix = '.dylib' - else: - shared_library_suffix = '.so' - - lib_filename = (shared_library_prefix + lib_name + - shared_library_suffix) - # Also copy libraries with ABI/SO version suffix - if sys.platform == 'darwin': - lib_pattern = (shared_library_prefix + lib_name + - ".*" + shared_library_suffix[1:]) - libs = glob.glob(pjoin(build_prefix, lib_pattern)) - else: - libs = glob.glob(pjoin(build_prefix, lib_filename) + '*') - - if not libs: - raise Exception('Could not find library:' + lib_filename + - ' in ' + build_prefix) - - # Longest suffix library should be copied, all others ignored and can be - # symlinked later after the library has been installed - libs.sort(key=lambda s: -len(s)) - print(libs, libs[0]) - lib_filename = os.path.basename(libs[0]) - shutil.move(pjoin(build_prefix, lib_filename), - pjoin(build_lib, 'pyarrow', lib_filename)) - - # If the event of not running from a git clone (e.g. from a git archive # or a Python sdist), see if we can set the version number ourselves default_version = '11.0.0-SNAPSHOT'