meta.yaml

{% set version = "14.0.1" %}
{% set cuda_enabled = cuda_compiler_version != "None" %}
{% set build_ext_version = "5.0.0" %}
{% set build_ext = "cuda" if cuda_enabled else "cpu" %}
{% set proc_build_number = "0" %}
{% set llvm_version = "15" %}

# see https://github.com/apache/arrow/blob/apache-arrow-10.0.1/cpp/CMakeLists.txt#L88-L90
{% set so_version = (version.split(".")[0] | int * 100 + version.split(".")[1] | int) ~ "." ~ version.split(".")[2] ~ ".0" %}

package:
  name: apache-arrow
  version: {{ version }}

source:
  # arrow has the unfortunate habit of changing tags of X.0.0 in the
  # lead-up until release -> don't use github sources on main
  # - url: https://github.com/apache/arrow/archive/refs/tags/apache-arrow-{{ version }}.tar.gz
  - url: https://dist.apache.org/repos/dist/release/arrow/arrow-{{ version }}/apache-arrow-{{ version }}.tar.gz
    sha256: 5c70eafb1011f9d124bafb328afe54f62cc5b9280b7080e1e3d668f78c0e407e
    patches:
      # backport https://github.com/apache/arrow/pull/38375
      - patches/0001-GH-38364-Python-Initialize-S3-on-first-use-38375.patch
      # workaround for https://github.com/apache/arrow/issues/37692
      - patches/0002-fixture-teardown-should-not-fail-test.patch
  # testing-submodule not part of release tarball
  - git_url: https://github.com/apache/arrow-testing.git
    git_rev: 47f7b56b25683202c1fd957668e13f2abafc0f12
    folder: testing

build:
  number: 6
  # for cuda support, building with one version is enough to be compatible with
  # all later versions, since arrow is only using libcuda, and not libcudart.
  skip: true  # [cuda_compiler_version not in ("None", cuda_compiler_version_min)]
  # arrow promises API- & ABI-compatibility along SemVer, see #1096

requirements:
  build:
    - {{ compiler("c") }}
    - {{ compiler("cxx") }}
    - {{ compiler("cuda") }}                 # [cuda_compiler_version != "None"]
    # needs to run protoc & grpc_cpp_plugin
    - libgrpc                                # [build_platform != target_platform]
    - libprotobuf                            # [build_platform != target_platform]
    # needed for gandiva
    - clangdev {{ llvm_version }}            # [build_platform != target_platform]
    - llvmdev {{ llvm_version }}             # [build_platform != target_platform]
    - gnuconfig                              # [build_platform != target_platform]
    - cmake
    - ninja
    # necessary for vendored jemalloc
    - autoconf     # [linux]
    - make         # [linux]
  host:
    # for required dependencies, see
    # https://github.com/apache/arrow/blob/apache-arrow-11.0.0/cpp/cmake_modules/ThirdpartyToolchain.cmake#L46-L75
    - clangdev {{ llvm_version }}
    - llvmdev {{ llvm_version }}
    - aws-crt-cpp
    - aws-sdk-cpp
    - brotli
    - bzip2
    # not yet: https://github.com/conda-forge/cpp-opentelemetry-sdk-feedstock/issues/38
    # - cpp-opentelemetry-sdk
    # - proto-opentelemetry-proto =={{ cpp_opentelemetry_sdk }}
    - gflags
    - glog
    - google-cloud-cpp
    # arrow uses a customized jemalloc, see #944
    # - jemalloc
    - libabseil
    - libboost-headers
    - libutf8proc
    - lz4-c
    - nlohmann_json
    - orc
    - rapidjson
    - re2
    - snappy
    - thrift-cpp
    - ucx          # [linux]
    - xsimd
    - zlib
    - zstd

outputs:
  - name: apache-arrow-proc
    version: {{ build_ext_version }}
    build:
      number: {{ proc_build_number }}
      string: {{ build_ext }}
    requirements:
      run_constrained:
        # avoid installation with old naming of proc package
        - arrow-cpp-proc <0.0a0
    test:
      commands:
        - exit 0
    about:
      home: http://github.com/apache/arrow
      license: Apache-2.0
      license_file:
        - LICENSE.txt
      summary: A meta-package to select Arrow build variant

  - name: libarrow-all
    script: install-libarrow.sh   # [unix]
    script: install-libarrow.bat  # [win]
    version: {{ version }}
    build:
      string: h{{ PKG_HASH }}_{{ PKG_BUILDNUM }}_{{ build_ext }}
      run_exports:
        - {{ pin_subpackage("libarrow", max_pin="x") }}
        - {{ pin_subpackage("libarrow-acero", max_pin="x") }}
        - {{ pin_subpackage("libarrow-dataset", max_pin="x") }}
        - {{ pin_subpackage("libarrow-flight", max_pin="x") }}
        - {{ pin_subpackage("libarrow-flight-sql", max_pin="x") }}
        - {{ pin_subpackage("libarrow-gandiva", max_pin="x") }}
        - {{ pin_subpackage("libarrow-substrait", max_pin="x") }}
        - {{ pin_subpackage("libparquet", max_pin="x") }}
    requirements:
      build:
        - cmake
        - ninja
      host:
        - {{ pin_subpackage("libarrow", exact=True) }}
        - {{ pin_subpackage("libarrow-acero", exact=True) }}
        - {{ pin_subpackage("libarrow-dataset", exact=True) }}
        - {{ pin_subpackage("libarrow-flight", exact=True) }}
        - {{ pin_subpackage("libarrow-flight-sql", exact=True) }}
        - {{ pin_subpackage("libarrow-gandiva", exact=True) }}
        - {{ pin_subpackage("libarrow-substrait", exact=True) }}
        - {{ pin_subpackage("libparquet", exact=True) }}
      run:
        - {{ pin_subpackage("libarrow", exact=True) }}
        - {{ pin_subpackage("libarrow-acero", exact=True) }}
        - {{ pin_subpackage("libarrow-dataset", exact=True) }}
        - {{ pin_subpackage("libarrow-flight", exact=True) }}
        - {{ pin_subpackage("libarrow-flight-sql", exact=True) }}
        - {{ pin_subpackage("libarrow-gandiva", exact=True) }}
        - {{ pin_subpackage("libarrow-substrait", exact=True) }}
        - {{ pin_subpackage("libparquet", exact=True) }}
    test:
      commands:
        - echo "tested in other outputs"

    about:
      home: http://github.com/apache/arrow
      license: Apache-2.0
      license_file:
        - LICENSE.txt
      summary: C++ libraries for Apache Arrow

  - name: libarrow
    script: install-libarrow.sh   # [unix]
    script: install-libarrow.bat  # [win]
    version: {{ version }}
    build:
      string: h{{ PKG_HASH }}_{{ PKG_BUILDNUM }}_{{ build_ext }}
      run_exports:
        - {{ pin_subpackage("libarrow", max_pin="x") }}
      ignore_run_exports_from:
        - {{ compiler("cuda") }}                 # [cuda_compiler_version != "None"]
        # arrow only uses headers, apparently
        - gflags
        # shared lib linked on unix, not on win
        - glog                                   # [win]
      ignore_run_exports:
        # we don't need all of brotli's run-exports
        - libbrotlicommon
      track_features: {{ "[arrow-cuda]" if cuda_enabled else "" }}
      missing_dso_whitelist:
        - '*/libcuda.so.*'    # [linux]
        - '*/nvcuda.dll'      # [win]
    requirements:
      build:
        - cmake
        - ninja
        # for strong run-exports
        - {{ compiler("c") }}
        - {{ compiler("cxx") }}
        - {{ compiler("cuda") }}                 # [cuda_compiler_version != "None"]
      host:
        - aws-crt-cpp
        - aws-sdk-cpp
        - brotli
        - bzip2
        # not yet: https://github.com/conda-forge/cpp-opentelemetry-sdk-feedstock/issues/38
        # - cpp-opentelemetry-sdk
        # - proto-opentelemetry-proto =={{ cpp_opentelemetry_sdk }}
        - gflags
        - glog
        - google-cloud-cpp
        # arrow uses a customized jemalloc, see #944
        # - jemalloc
        - libabseil
        - libutf8proc
        - lz4-c
        - openssl    # [win]
        - orc
        - re2
        - snappy
        - zlib
        - zstd
        - __cuda >={{ cuda_compiler_version_min }}  # [cuda_compiler_version != "None"]
        # since libgoogle-cloud is static on windows, see
        # https://github.com/conda-forge/google-cloud-cpp-feedstock/pull/108,
        # its host deps (which aren't yet covered above) leak into the build here
        - libcrc32c  # [win]
        - libcurl    # [win]
      run_constrained:
        - apache-arrow-proc =*={{ build_ext }}
        # avoid installation with old naming of lib package
        - arrow-cpp <0.0a0
        # old parquet lib output, now part of this feedstock
        - parquet-cpp <0.0a0
        # since all the other libarrow-* variants in this recipe depend exactly on libarrow,
        # this avoids that libarrow-X & -Y get installed with different builds or versions.

    test:
      commands:
        # headers
        - test -f $PREFIX/include/arrow/api.h               # [unix]
        - if not exist %LIBRARY_INC%\arrow\api.h exit 1     # [win]

        {% set libs = ["arrow"] + (cuda_compiler_version != "None") * ["arrow_cuda"] %}
        {% for each_lib in libs %}
        # shared
        - test -f $PREFIX/lib/lib{{ each_lib }}.so                 # [linux]
        - test -f $PREFIX/lib/lib{{ each_lib }}.dylib              # [osx]
        - if not exist %LIBRARY_BIN%\{{ each_lib }}.dll exit 1     # [win]
        - if not exist %LIBRARY_LIB%\{{ each_lib }}.lib exit 1     # [win]

        # absence of static libraries
        - test ! -f $PREFIX/lib/lib{{ each_lib }}.a                # [unix]
        - if exist %LIBRARY_LIB%\{{ each_lib }}_static.lib exit 1  # [win]
        {% endfor %}

        # absence of arrow_cuda for CPU builds
        - test ! -f $PREFIX/lib/libarrow_cuda.so                   # [(cuda_compiler_version == "None") and linux]
        - test ! -f $PREFIX/lib/libarrow_cuda.a                    # [(cuda_compiler_version == "None") and linux]
        - if exist %LIBRARY_BIN%\arrow_cuda.dll exit 1             # [(cuda_compiler_version == "None") and win]
        - if exist %LIBRARY_LIB%\arrow_cuda.lib exit 1             # [(cuda_compiler_version == "None") and win]
        - if exist %LIBRARY_LIB%\arrow_cuda_static.lib exit 1      # [(cuda_compiler_version == "None") and win]

        # gdb-wrapper (paths are stacked intentionally)
        - test -f $PREFIX/share/gdb/auto-load/$PREFIX/lib/libarrow.so.{{ so_version }}-gdb.py     # [linux]
        - test -f $PREFIX/share/gdb/auto-load/$PREFIX/lib/libarrow.{{ so_version }}.dylib-gdb.py  # [osx]

        {% set libs = [
            "arrow_acero", "arrow_dataset", "arrow_flight",
            "arrow_flight_sql", "arrow_substrait", "gandiva", "parquet"
        ] %}
        {% for each_lib in libs %}
        # absence of libraries that belong in other outputs
        - test ! -f $PREFIX/lib/lib{{ each_lib }}.so                # [linux]
        - test ! -f $PREFIX/lib/lib{{ each_lib }}.dylib             # [osx]
        - if exist %LIBRARY_BIN%\{{ each_lib }}.dll exit 1          # [win]
        - if exist %LIBRARY_LIB%\{{ each_lib }}.lib exit 1          # [win]
        {% endfor %}

    about:
      home: http://github.com/apache/arrow
      license: Apache-2.0
      license_file:
        - LICENSE.txt
      summary: C++ libraries for Apache Arrow core

  - name: libarrow-acero
    script: install-libarrow.sh   # [unix]
    script: install-libarrow.bat  # [win]
    version: {{ version }}
    build:
      string: h{{ PKG_HASH }}_{{ PKG_BUILDNUM }}_{{ build_ext }}
      run_exports:
        - {{ pin_subpackage("libarrow-acero", max_pin="x") }}
    requirements:
      build:
        - cmake
        - ninja
        # for strong run-exports
        - {{ compiler("c") }}
        - {{ compiler("cxx") }}
      host:
        - {{ pin_subpackage("libarrow", exact=True) }}
      run:
        - {{ pin_subpackage("libarrow", exact=True) }}
      # run-constraints handled by libarrow, since we depend on it with exact=True

    test:
      commands:
        # headers
        - test -f $PREFIX/include/arrow/acero/api.h             # [unix]
        - if not exist %LIBRARY_INC%\arrow\acero\api.h exit 1   # [win]

        # shared libraries
        - test -f $PREFIX/lib/libarrow_acero.so                 # [linux]
        - test -f $PREFIX/lib/libarrow_acero.dylib              # [osx]
        - if not exist %LIBRARY_BIN%\arrow_acero.dll exit 1     # [win]
        - if not exist %LIBRARY_LIB%\arrow_acero.lib exit 1     # [win]

        # absence of static libraries
        - test ! -f $PREFIX/lib/libarrow_acero.a                # [unix]
        - if exist %LIBRARY_LIB%\arrow_acero_static.lib exit 1  # [win]

    about:
      home: http://github.com/apache/arrow
      license: Apache-2.0
      license_file:
        - LICENSE.txt
      summary: C++ libraries for Apache Arrow Acero

  - name: libarrow-dataset
    script: install-libarrow.sh   # [unix]
    script: install-libarrow.bat  # [win]
    version: {{ version }}
    build:
      string: h{{ PKG_HASH }}_{{ PKG_BUILDNUM }}_{{ build_ext }}
      run_exports:
        - {{ pin_subpackage("libarrow-dataset", max_pin="x") }}
    requirements:
      build:
        - cmake
        - ninja
        # for strong run-exports
        - {{ compiler("c") }}
        - {{ compiler("cxx") }}
      host:
        - {{ pin_subpackage("libarrow", exact=True) }}
        - {{ pin_subpackage("libarrow-acero", exact=True) }}
        - {{ pin_subpackage("libparquet", exact=True) }}
      run:
        - {{ pin_subpackage("libarrow", exact=True) }}
        - {{ pin_subpackage("libarrow-acero", exact=True) }}
        - {{ pin_subpackage("libparquet", exact=True) }}
      # run-constraints handled by libarrow, since we depend on it with exact=True

    test:
      commands:
        # headers
        - test -f $PREFIX/include/arrow/dataset/api.h               # [unix]
        - if not exist %LIBRARY_INC%\arrow\dataset\api.h exit 1     # [win]

        # shared libraries
        - test -f $PREFIX/lib/libarrow_dataset.so                   # [linux]
        - test -f $PREFIX/lib/libarrow_dataset.dylib                # [osx]
        - if not exist %LIBRARY_BIN%\arrow_dataset.dll exit 1       # [win]
        - if not exist %LIBRARY_LIB%\arrow_dataset.lib exit 1       # [win]

        # absence of static libraries
        - test ! -f $PREFIX/lib/libarrow_dataset.a                  # [unix]
        - if exist %LIBRARY_LIB%\arrow_dataset_static.lib exit 1    # [win]

    about:
      home: http://github.com/apache/arrow
      license: Apache-2.0
      license_file:
        - LICENSE.txt
      summary: C++ libraries for Apache Arrow Dataset

  - name: libarrow-flight
    script: install-libarrow.sh   # [unix]
    script: install-libarrow.bat  # [win]
    version: {{ version }}
    build:
      string: h{{ PKG_HASH }}_{{ PKG_BUILDNUM }}_{{ build_ext }}
      run_exports:
        - {{ pin_subpackage("libarrow-flight", max_pin="x") }}
    requirements:
      build:
        - cmake
        - ninja
        # for strong run-exports
        - {{ compiler("c") }}
        - {{ compiler("cxx") }}
        # needs to run protoc & grpc_cpp_plugin
        - libgrpc                                # [build_platform != target_platform]
        - libprotobuf                            # [build_platform != target_platform]
      host:
        - {{ pin_subpackage("libarrow", exact=True) }}
        - libabseil
        - libgrpc
        - libprotobuf
        - ucx          # [linux]
      run:
        - {{ pin_subpackage("libarrow", exact=True) }}
      # run-constraints handled by libarrow, since we depend on it with exact=True

    test:
      commands:
        # headers
        - test -f $PREFIX/include/arrow/flight/types.h              # [unix]
        - if not exist %LIBRARY_INC%\arrow\flight\types.h exit 1    # [win]

        # shared libraries
        - test -f $PREFIX/lib/libarrow_flight.so                    # [linux]
        - test -f $PREFIX/lib/libarrow_flight.dylib                 # [osx]
        - if not exist %LIBRARY_BIN%\arrow_flight.dll exit 1        # [win]
        - if not exist %LIBRARY_LIB%\arrow_flight.lib exit 1        # [win]

        # absence of static libraries
        - test ! -f $PREFIX/lib/libarrow_flight.a                   # [unix]
        - if exist %LIBRARY_LIB%\arrow_flight_static.lib exit 1     # [win]

        # Only check UCX on Linux
        - test -f $PREFIX/lib/libarrow_flight_transport_ucx.so      # [linux]

    about:
      home: http://github.com/apache/arrow
      license: Apache-2.0
      license_file:
        - LICENSE.txt
      summary: C++ libraries for Apache Arrow Flight

  - name: libarrow-flight-sql
    script: install-libarrow.sh   # [unix]
    script: install-libarrow.bat  # [win]
    version: {{ version }}
    build:
      string: h{{ PKG_HASH }}_{{ PKG_BUILDNUM }}_{{ build_ext }}
      run_exports:
        - {{ pin_subpackage("libarrow-flight-sql", max_pin="x") }}
    requirements:
      build:
        - cmake
        - ninja
        # for strong run-exports
        - {{ compiler("c") }}
        - {{ compiler("cxx") }}
        # needs to run protoc & grpc_cpp_plugin
        - libgrpc                                # [build_platform != target_platform]
        - libprotobuf                            # [build_platform != target_platform]
      host:
        - {{ pin_subpackage("libarrow", exact=True) }}
        - {{ pin_subpackage("libarrow-flight", exact=True) }}
        - libprotobuf
      run:
        - {{ pin_subpackage("libarrow", exact=True) }}
        - {{ pin_subpackage("libarrow-flight", exact=True) }}
      # run-constraints handled by libarrow, since we depend on it with exact=True

    test:
      commands:
        # headers
        - test -f $PREFIX/include/arrow/flight/sql/api.h                # [unix]
        - if not exist %LIBRARY_INC%\arrow\flight\sql\api.h exit 1      # [win]

        # shared libraries
        - test -f $PREFIX/lib/libarrow_flight_sql.so                    # [linux]
        - test -f $PREFIX/lib/libarrow_flight_sql.dylib                 # [osx]
        - if not exist %LIBRARY_BIN%\arrow_flight_sql.dll exit 1        # [win]
        - if not exist %LIBRARY_LIB%\arrow_flight_sql.lib exit 1        # [win]

        # absence of static libraries
        - test ! -f $PREFIX/lib/libarrow_flight_sql.a                   # [unix]
        - if exist %LIBRARY_LIB%\arrow_flight_sql_static.lib exit 1     # [win]

    about:
      home: http://github.com/apache/arrow
      license: Apache-2.0
      license_file:
        - LICENSE.txt
      summary: C++ libraries for Apache Arrow Flight SQL

  - name: libarrow-gandiva
    script: install-libarrow.sh   # [unix]
    script: install-libarrow.bat  # [win]
    version: {{ version }}
    build:
      string: h{{ PKG_HASH }}_{{ PKG_BUILDNUM }}_{{ build_ext }}
      run_exports:
        - {{ pin_subpackage("libarrow-gandiva", max_pin="x") }}
    requirements:
      build:
        - cmake
        - ninja
        # for strong run-exports
        - {{ compiler("c") }}
        - {{ compiler("cxx") }}
      host:
        - {{ pin_subpackage("libarrow", max_pin="x") }}
        - libutf8proc
        # gandiva requires shared libllvm; needs to match version used at build time
        - llvm {{ llvm_version }}  # [unix]
        - openssl
        - re2
        - zlib  # [win]
      run:
        - {{ pin_subpackage("libarrow", exact=True) }}
      # run-constraints handled by libarrow, since we depend on it with exact=True

    test:
      commands:
        # headers
        - test -f $PREFIX/include/gandiva/engine.h              # [unix]
        - if not exist %LIBRARY_INC%\gandiva\engine.h exit 1    # [win]

        # shared libraries
        - test -f $PREFIX/lib/libgandiva.so                     # [linux]
        - test -f $PREFIX/lib/libgandiva.dylib                  # [osx]
        - if not exist %LIBRARY_BIN%\gandiva.dll exit 1         # [win]
        - if not exist %LIBRARY_LIB%\gandiva.lib exit 1         # [win]

        # absence of static libraries
        - test ! -f $PREFIX/lib/libgandiva.a                    # [unix]
        - if exist %LIBRARY_LIB%\gandiva_static.lib exit 1      # [win]

    about:
      home: http://github.com/apache/arrow
      license: Apache-2.0
      license_file:
        - LICENSE.txt
      summary: C++ libraries for Apache Arrow Gandiva

  - name: libarrow-substrait
    script: install-libarrow.sh   # [unix]
    script: install-libarrow.bat  # [win]
    version: {{ version }}
    build:
      string: h{{ PKG_HASH }}_{{ PKG_BUILDNUM }}_{{ build_ext }}
      run_exports:
        - {{ pin_subpackage("libarrow-substrait", max_pin="x") }}
    requirements:
      build:
      build:
        - cmake
        - ninja
        # for strong run-exports
        - {{ compiler("c") }}
        - {{ compiler("cxx") }}
        - libprotobuf                            # [build_platform != target_platform]
        # for strong run-exports
        - {{ compiler("c") }}
        - {{ compiler("cxx") }}
        - cmake
        - ninja
      host:
        - {{ pin_subpackage("libarrow", exact=True) }}
        - {{ pin_subpackage("libarrow-acero", exact=True) }}
        - {{ pin_subpackage("libarrow-dataset", exact=True) }}
        - libabseil  # [win]
        - libprotobuf
      run:
        - {{ pin_subpackage("libarrow", exact=True) }}
        - {{ pin_subpackage("libarrow-acero", exact=True) }}
        - {{ pin_subpackage("libarrow-dataset", exact=True) }}
      # run-constraints handled by libarrow, since we depend on it with exact=True

    test:
      commands:
        # headers
        - test -f $PREFIX/include/arrow/engine/substrait/api.h              # [unix]
        - if not exist %LIBRARY_INC%\arrow\engine\substrait\api.h exit 1    # [win]

        # shared libraries
        - test -f $PREFIX/lib/libarrow_substrait.so                         # [linux]
        - test -f $PREFIX/lib/libarrow_substrait.dylib                      # [osx]
        - if not exist %LIBRARY_BIN%\arrow_substrait.dll exit 1             # [win]
        - if not exist %LIBRARY_LIB%\arrow_substrait.lib exit 1             # [win]

        # absence of static libraries
        - test ! -f $PREFIX/lib/libarrow_substrait.a                        # [unix]
        - if exist %LIBRARY_LIB%\arrow_substrait_static.lib exit 1          # [win]

    about:
      home: http://github.com/apache/arrow
      license: Apache-2.0
      license_file:
        - LICENSE.txt
      summary: C++ libraries for Apache Arrow Substrait

  - name: libparquet
    script: install-libarrow.sh   # [unix]
    script: install-libarrow.bat  # [win]
    version: {{ version }}
    build:
      string: h{{ PKG_HASH }}_{{ PKG_BUILDNUM }}_{{ build_ext }}
      run_exports:
        - {{ pin_subpackage("libparquet", max_pin="x") }}
    requirements:
      build:
        - cmake
        - ninja
        # for strong run-exports
        - {{ compiler("c") }}
        - {{ compiler("cxx") }}
      host:
        - {{ pin_subpackage("libarrow", max_pin="x") }}
        - openssl
        - thrift-cpp
      run:
        - {{ pin_subpackage("libarrow", exact=True) }}
      # run-constraints handled by libarrow, since we depend on it with exact=True

    test:
      commands:
        # headers
        - test -f $PREFIX/include/parquet/api/reader.h              # [unix]
        - if not exist %LIBRARY_INC%\parquet\api\reader.h exit 1    # [win]

        # shared libraries
        - test -f $PREFIX/lib/libparquet.so                         # [linux]
        - test -f $PREFIX/lib/libparquet.dylib                      # [osx]
        - if not exist %LIBRARY_BIN%\parquet.dll exit 1             # [win]
        - if not exist %LIBRARY_LIB%\parquet.lib exit 1             # [win]

        # absence of static libraries
        - test ! -f $PREFIX/lib/libparquet.a                        # [unix]
        - if exist %LIBRARY_LIB%\parquet_static.lib exit 1          # [win]

    about:
      home: http://github.com/apache/arrow
      license: Apache-2.0
      license_file:
        - LICENSE.txt
      summary: C++ libraries for Apache Parquet

  - name: pyarrow
    script: build-pyarrow.sh   # [unix]
    script: build-pyarrow.bat  # [win]
    version: {{ version }}
    build:
      string: py{{ CONDA_PY }}h{{ PKG_HASH }}_{{ PKG_BUILDNUM }}_{{ build_ext }}
      ignore_run_exports_from:
        - {{ compiler("cuda") }}                 # [cuda_compiler_version != "None"]
      track_features: {{ "[arrow-cuda]" if cuda_enabled else "" }}
      rpaths:
        - lib/
        - {{ SP_DIR }}/pyarrow
      missing_dso_whitelist:
        # not actually missing, but installed into SP_DIR, see tests
        - '*/arrow_python.dll'                # [win]
        - '*/arrow_python_flight.dll'         # [win]
    requirements:
      build:
        - {{ compiler("c") }}
        - {{ compiler("cxx") }}
        # pyarrow does not require nvcc but it needs to link against libraries in libarrow=*=*cuda
        - {{ compiler("cuda") }}                 # [cuda_compiler_version != "None"]
        - python                                 # [build_platform != target_platform]
        - cross-python_{{ target_platform }}     # [build_platform != target_platform]
        - cython                                 # [build_platform != target_platform]
        - numpy                                  # [build_platform != target_platform]
        - cmake
        - ninja
      host:
        - {{ pin_subpackage("libarrow-all", exact=True) }}
        - clangdev {{ llvm_version }}
        - llvmdev {{ llvm_version }}
        - cython
        - numpy
        - python
        - setuptools
        # see https://github.com/apache/arrow/issues/37931
        - setuptools_scm <8
      run:
        # full set of libs because run-exports from libarrow-all aren't picked up
        - {{ pin_subpackage("libarrow", exact=True) }}
        - {{ pin_subpackage("libarrow-acero", exact=True) }}
        - {{ pin_subpackage("libarrow-dataset", exact=True) }}
        - {{ pin_subpackage("libarrow-flight", exact=True) }}
        - {{ pin_subpackage("libarrow-flight-sql", exact=True) }}
        - {{ pin_subpackage("libarrow-gandiva", exact=True) }}
        - {{ pin_subpackage("libarrow-substrait", exact=True) }}
        - {{ pin_subpackage("libparquet", exact=True) }}
        - {{ pin_compatible('numpy') }}
        - python
      run_constrained:
        - apache-arrow-proc =*={{ build_ext }}

    test:
      files:
        - test_read_parquet.py
      imports:
        - pyarrow
        - pyarrow.dataset
        - pyarrow.compute
        - pyarrow.flight
        - pyarrow.gandiva
        - pyarrow.orc      # [unix]
        - pyarrow.parquet
        - pyarrow.fs
        - pyarrow._s3fs
        - pyarrow._hdfs
        # We can only test importing cuda package but cannot run when a
        # CUDA device is not available, for instance, when building from CI.
        # On Windows, we cannot even do that due to `nvcuda.dll` not being found, see
        # https://conda-forge.org/docs/maintainer/knowledge_base.html#nvcuda-dll-cannot-be-found-on-windows
        # However, we check below for (at least) the presence of a correctly-compiled module
        - pyarrow.cuda     # [cuda_compiler_version != "None" and not win]
      commands:
        # libraries that depend on python (and hence aren't in libarrow itself)
        - test -f ${SP_DIR}/pyarrow/libarrow_python.so                            # [linux]
        - test -f ${SP_DIR}/pyarrow/libarrow_python_flight.so                     # [linux]
        - test -f ${SP_DIR}/pyarrow/libarrow_python.dylib                         # [osx]
        - test -f ${SP_DIR}/pyarrow/libarrow_python_flight.dylib                  # [osx]
        - if not exist %SP_DIR%\pyarrow\arrow_python.dll exit 1                   # [win]
        - if not exist %SP_DIR%\pyarrow\arrow_python_flight.dll exit 1            # [win]

        - test -f ${SP_DIR}/pyarrow/include/arrow/python/pyarrow.h                # [unix]
        - if not exist %SP_DIR%\pyarrow\include\arrow\python\pyarrow.h exit 1     # [win]

        - test ! -f ${SP_DIR}/pyarrow/tests/test_array.py                         # [unix]
        - if exist %SP_DIR%/pyarrow/tests/test_array.py exit 1                    # [win]
        # Need to remove dot from PY_VER; %MYVAR:x=y% replaces "x" in %MYVAR% with "y"
        - if not exist %SP_DIR%/pyarrow/_cuda.cp%PY_VER:.=%-win_amd64.pyd exit 1  # [win and cuda_compiler_version != "None"]
        - python test_read_parquet.py

    about:
      home: http://github.com/apache/arrow
      license: Apache-2.0
      license_file:
        - LICENSE.txt
      summary: Python libraries for Apache Arrow

  - name: pyarrow-tests
    script: build-pyarrow.sh   # [unix]
    script: build-pyarrow.bat  # [win]
    version: {{ version }}
    build:
      string: py{{ CONDA_PY }}h{{ PKG_HASH }}_{{ PKG_BUILDNUM }}_{{ build_ext }}
      ignore_run_exports_from:
        - {{ compiler("cuda") }}                 # [cuda_compiler_version != "None"]
      track_features: {{ "[arrow-cuda]" if cuda_enabled else "" }}
    requirements:
      build:
        - {{ compiler("c") }}
        - {{ compiler("cxx") }}
        # pyarrow does not require nvcc but it needs to link against libraries in libarrow=*=*cuda
        - {{ compiler("cuda") }}                 # [cuda_compiler_version != "None"]
        - python                                 # [build_platform != target_platform]
        - cross-python_{{ target_platform }}     # [build_platform != target_platform]
        - cython                                 # [build_platform != target_platform]
        - numpy                                  # [build_platform != target_platform]
        - cmake
        - ninja
      host:
        - {{ pin_subpackage("libarrow-all", exact=True) }}
        - {{ pin_subpackage('pyarrow', exact=True) }}
        - clangdev {{ llvm_version }}
        - llvmdev {{ llvm_version }}
        - cython
        - numpy
        - python
        - setuptools
        # see https://github.com/apache/arrow/issues/37931
        - setuptools_scm <8
      run:
        - {{ pin_subpackage('pyarrow', exact=True) }}
        - python
      run_constrained:
        - apache-arrow-proc =*={{ build_ext }}

    {% if not (aarch64 or ppc64le) or py == 311 %}
    # only run the full test suite for one python version when in emulation
    # (each run can take up to ~45min); there's essentially zero divergence
    # in behaviour across python versions anyway
    test:
      requires:
        # test_cpp_extension_in_python requires a compiler
        - {{ compiler("cxx") }}  # [linux]
        - pytest
        - pytest-lazy-fixture
        - backports.zoneinfo     # [py<39]
        - boto3
        - cffi
        - cloudpickle
        - cython
        - fastparquet
        - fsspec
        - hypothesis
        - minio-server
        - pandas
        - s3fs >=2023
        - scipy
        # these are generally (far) behind on migrating abseil/grpc/protobuf,
        # and using them as test dependencies blocks the migrator unnecessarily
        # - pytorch
        # - tensorflow
        # we're not building java bindings
        # - jpype1
        # doesn't get picked up correctly
        # - libhdfs3
        # causes segfaults
        # - sparse
      source_files:
        - testing/data
      commands:
        - cd ${SP_DIR}                                      # [unix]
        - cd %SP_DIR%                                       # [win]
        - export ARROW_TEST_DATA="${SRC_DIR}/testing/data"  # [unix]
        - set "ARROW_TEST_DATA=%SRC_DIR%\testing\data"      # [win]

        {% set tests_to_skip = "_not_a_real_test" %}
        # we do not have GPUs in CI --> cannot test cuda
        {% set tests_to_skip = tests_to_skip + " or test_cuda" %}
        # skip tests that raise SIGINT and crash the test suite
        {% set tests_to_skip = tests_to_skip + " or (test_csv and test_cancellation)" %}  # [linux]
        {% set tests_to_skip = tests_to_skip + " or (test_flight and test_interrupt)" %}  # [linux]
        # skip tests that make invalid(-for-conda) assumptions about the compilers setup
        {% set tests_to_skip = tests_to_skip + " or test_cython_api" %}                   # [unix]
        {% set tests_to_skip = tests_to_skip + " or test_visit_strings" %}                # [unix]
        # skip tests that cannot succeed in emulation
        {% set tests_to_skip = tests_to_skip + " or test_debug_memory_pool_disabled" %}   # [aarch64 or ppc64le]
        {% set tests_to_skip = tests_to_skip + " or test_env_var_io_thread_count" %}      # [aarch64 or ppc64le]
        # vvvvvvv TESTS THAT SHOULDN'T HAVE TO BE SKIPPED vvvvvvv
        # problems with minio
        {% set tests_to_skip = tests_to_skip + " or (test_delete_dir and S3FileSystem)" %}
        {% set tests_to_skip = tests_to_skip + " or (test_get_file_info and S3FileSystem)" %}
        {% set tests_to_skip = tests_to_skip + " or (test_move_directory and S3FileSystem)" %}
        # XMinioInvalidObjectName on win: "Object name contains unsupported characters"
        {% set tests_to_skip = tests_to_skip + " or test_write_to_dataset_with_partitions_s3fs" %}  # [win]
        # gandiva tests are segfaulting on ppc
        {% set tests_to_skip = tests_to_skip + " or test_gandiva" %}                                # [ppc64le]
        # test failures on ppc (both failing with: Float value was truncated converting to int32)
        {% set tests_to_skip = tests_to_skip + " or test_safe_cast_from_float_with_nans_to_int" %}  # [ppc64le]
        {% set tests_to_skip = tests_to_skip + " or test_float_with_null_as_integer" %}             # [ppc64le]
        # ^^^^^^^ TESTS THAT SHOULDN'T HAVE TO BE SKIPPED ^^^^^^^
        - pytest pyarrow/ -rfEs -k "not ({{ tests_to_skip }})"
    {% endif %}

    about:
      home: http://github.com/apache/arrow
      license: Apache-2.0
      license_file:
        - LICENSE.txt
      summary: Python test files for Apache Arrow

about:
  home: http://github.com/apache/arrow
  license: Apache-2.0
  license_file:
    - LICENSE.txt
  summary: C++ and Python libraries for Apache Arrow

extra:
  recipe-maintainers:
    - wesm
    - xhochy
    - leifwalsh
    - jreback
    - cpcloud
    - pcmoritz
    - robertnishihara
    - siddharthteotia
    - kou
    - kszucs
    - pitrou
    - pearu
    - nealrichardson
    - jakirkham
    - h-vetinari
  feedstock-name: arrow-cpp