[ceph.git] / ceph / src / arrow / dev / tasks / conda-recipes / arrow-cpp / meta.yaml

# NOTE: In constrast to the conda-forge recipe, ARROW_VERSION is a templated variable here.
{% set version = ARROW_VERSION %}
{% set cuda_enabled = cuda_compiler_version != "None" %}
{% set build_ext_version = ARROW_VERSION %}
{% set build_ext = "cuda" if cuda_enabled else "cpu" %}
{% set proc_build_number = "0" %}

package:
  name: arrow-cpp-ext
  version: {{ version }}

source:
  path: ../../../../

build:
  number: 0
  # for cuda on win/linux, building with 9.2 is enough to be compatible with all later versions,
  # since arrow is only using libcuda, and not libcudart.
  skip: true  # [(win or linux) and cuda_compiler_version not in ("None", "10.2")]
  skip: true  # [osx and cuda_compiler_version != "None"]
  run_exports:
    - {{ pin_subpackage("arrow-cpp", max_pin="x.x.x") }}

outputs:
  - name: arrow-cpp-proc
    version: {{ build_ext_version }}
    build:
      number: {{ proc_build_number }}
      string: "{{ build_ext }}"
    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: arrow-cpp
    script: build-arrow.sh  # [not win]
    script: bld-arrow.bat   # [win]
    version: {{ version }}
    build:
      string: py{{ CONDA_PY }}h{{ PKG_HASH }}_{{ PKG_BUILDNUM }}_{{ build_ext }}
      run_exports:
        - {{ pin_subpackage("arrow-cpp", max_pin="x.x.x") }}
      ignore_run_exports:
        - cudatoolkit
      track_features:
        {{ "- arrow-cuda" if cuda_enabled else "" }}
    requirements:
      build:
        - python                                 # [build_platform != target_platform]
        - cross-python_{{ target_platform }}     # [build_platform != target_platform]
        - cython                                 # [build_platform != target_platform]
        - numpy                                  # [build_platform != target_platform]
        - gnuconfig                              # [osx and arm64]
        - libprotobuf
        - grpc-cpp
        - cmake
        - autoconf  # [unix]
        - ninja
        - make  # [unix]
        - {{ compiler('c') }}
        - {{ compiler('cxx') }}
        - {{ compiler("cuda") }}  # [cuda_compiler_version != "None"]
      host:
        - aws-sdk-cpp
        - boost-cpp >=1.70
        - brotli
        - bzip2
        - c-ares
        - gflags
        - glog
        - grpc-cpp
        - libprotobuf
        - clangdev 10  # [not (osx and arm64)]
        - llvmdev 10   # [not (osx and arm64)]
        - libutf8proc
        - lz4-c
        - numpy
        - orc  # [unix]
        - python
        - rapidjson
        - re2
        - snappy
        - thrift-cpp
        - zlib
        - zstd
      run:
        - {{ pin_compatible('numpy', lower_bound='1.16') }}
        - python
      run_constrained:
        - arrow-cpp-proc * {{ build_ext }}
        - cudatoolkit >=9.2  # [cuda_compiler_version != "None"]

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

    test:
      commands:
        # headers
        - test -f $PREFIX/include/arrow/api.h              # [unix]
        - test -f $PREFIX/include/arrow/flight/types.h     # [unix]
        - test -f $PREFIX/include/plasma/client.h          # [unix]
        - test -f $PREFIX/include/gandiva/engine.h         # [unix and not (osx and arm64)]
        - test -f $PREFIX/include/parquet/api/reader.h     # [unix]
        - if not exist %LIBRARY_INC%\\arrow\\api.h exit 1            # [win]
        - if not exist %LIBRARY_INC%\\gandiva\\engine.h exit 1       # [win]
        - if not exist %LIBRARY_INC%\\parquet\\api\\reader.h exit 1  # [win]

        # shared
        - test -f $PREFIX/lib/libarrow.so            # [linux]
        - test -f $PREFIX/lib/libarrow_dataset.so    # [linux]
        - test -f $PREFIX/lib/libarrow_flight.so     # [linux]
        - test -f $PREFIX/lib/libarrow_python.so     # [linux]
        - test -f $PREFIX/lib/libparquet.so          # [linux]
        - test -f $PREFIX/lib/libgandiva.so          # [linux]
        - test -f $PREFIX/lib/libplasma.so           # [linux]
        - test -f $PREFIX/lib/libarrow_cuda${SHLIB_EXT}               # [(cuda_compiler_version != "None") and unix]
        - test ! -f $PREFIX/lib/libarrow_cuda${SHLIB_EXT}             # [(cuda_compiler_version == "None") and unix]
        - if not exist %PREFIX%\\Library\\bin\\arrow_cuda.dll exit 1  # [(cuda_compiler_version != "None") and win]
        - if exist %PREFIX%\\Library\\bin\\arrow_cuda.dll exit 1      # [(cuda_compiler_version == "None") and win]
        - test -f $PREFIX/lib/libarrow.dylib          # [osx]
        - test -f $PREFIX/lib/libarrow_dataset.dylib  # [osx]
        - test -f $PREFIX/lib/libarrow_python.dylib   # [osx]
        - test -f $PREFIX/lib/libgandiva.dylib        # [osx and not arm64]
        - test -f $PREFIX/lib/libparquet.dylib        # [osx]
        - test -f $PREFIX/lib/libplasma.dylib         # [osx]
        - if not exist %PREFIX%\\Library\\bin\\arrow.dll exit 1          # [win]
        - if not exist %PREFIX%\\Library\\bin\\arrow_dataset.dll exit 1  # [win]
        - if not exist %PREFIX%\\Library\\bin\\arrow_flight.dll exit 1   # [win]
        - if not exist %PREFIX%\\Library\\bin\\arrow_python.dll exit 1   # [win]
        - if not exist %PREFIX%\\Library\\bin\\parquet.dll exit 1        # [win]
        - if not exist %PREFIX%\\Library\\bin\\gandiva.dll exit 1        # [win]

        # absence of static libraries
        - test ! -f $PREFIX/lib/libarrow.a          # [unix]
        - test ! -f $PREFIX/lib/libarrow_dataset.a  # [unix]
        - test ! -f $PREFIX/lib/libarrow_flight.a   # [unix]
        - test ! -f $PREFIX/lib/libarrow_python.a   # [unix]
        - test ! -f $PREFIX/lib/libplasma.a         # [unix]
        - test ! -f $PREFIX/lib/libparquet.a        # [unix]
        - test ! -f $PREFIX/lib/libgandiva.a        # [unix]
        - if exist %PREFIX%\\Library\\lib\\arrow_static.lib exit 1          # [win]
        - if exist %PREFIX%\\Library\\lib\\arrow_dataset_static.lib exit 1  # [win]
        - if exist %PREFIX%\\Library\\lib\\arrow_flight_static.lib exit 1   # [win]
        - if exist %PREFIX%\\Library\\lib\\arrow_python_static.lib exit 1   # [win]
        - if exist %PREFIX%\\Library\\lib\\parquet_static.lib exit 1        # [win]
        - if exist %PREFIX%\\Library\\lib\\gandiva_static.lib exit 1        # [win]

  - name: pyarrow
    script: build-pyarrow.sh  # [not win]
    script: bld-pyarrow.bat   # [win]
    version: {{ version }}
    build:
      string: py{{ CONDA_PY }}h{{ PKG_HASH }}_{{ PKG_BUILDNUM }}_{{ build_ext }}
      ignore_run_exports:
        - cudatoolkit
      track_features:
        {{ "- arrow-cuda" if cuda_enabled else "" }}
    requirements:
      build:
        - 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
        - make  # [unix]
        - {{ compiler('c') }}
        - {{ compiler('cxx') }}
        # pyarrow does not require nvcc but it needs to link against libraries in arrow-cpp=*=*cuda
        - {{ compiler("cuda") }}  # [cuda_compiler_version != "None"]
      host:
        - {{ pin_subpackage('arrow-cpp', exact=True) }}
        - cython
        - numpy
        - python
        - setuptools
        - setuptools_scm
        - six
      run:
        - {{ pin_subpackage('arrow-cpp', exact=True) }}
        - {{ pin_compatible('numpy', lower_bound='1.16') }}
        # empty parquet-cpp metapackage, force old versions to be uninstalled
        - parquet-cpp 1.5.1.*
        - python
      run_constrained:
        - arrow-cpp-proc * {{ build_ext }}
        - cudatoolkit >=9.2  # [cuda_compiler_version != "None"]

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

    test:
      imports:
        - pyarrow
        - pyarrow.dataset
        - pyarrow.flight
        - pyarrow.gandiva  # [not (osx and arm64)]
        - pyarrow.orc      # [unix]
        - pyarrow.parquet
        - pyarrow.plasma   # [unix]
        - 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:
        - 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"]

  - name: pyarrow-tests
    script: build-pyarrow.sh  # [not win]
    script: bld-pyarrow.bat   # [win]
    version: {{ version }}
    build:
      string: py{{ CONDA_PY }}h{{ PKG_HASH }}_{{ PKG_BUILDNUM }}_{{ build_ext }}
      ignore_run_exports:
        - cudatoolkit
      track_features:
        {{ "- arrow-cuda" if cuda_enabled else "" }}
    requirements:
      build:
        - 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
        - make  # [unix]
        - {{ compiler('c') }}
        - {{ compiler('cxx') }}
        # pyarrow does not require nvcc but it needs to link against libraries in arrow-cpp=*=*cuda
        - {{ compiler("cuda") }}  # [cuda_compiler_version != "None"]
      host:
        - {{ pin_subpackage('arrow-cpp', exact=True) }}
        - {{ pin_subpackage('pyarrow', exact=True) }}
        - cython
        - numpy
        - python
        - setuptools
        - setuptools_scm
        - six
      run:
        - {{ pin_subpackage('pyarrow', exact=True) }}
        - python
      run_constrained:
        - arrow-cpp-proc * {{ build_ext }}
        - cudatoolkit >=9.2  # [cuda_compiler_version != "None"]

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

    test:
      commands:
        - test -f ${SP_DIR}/pyarrow/tests/test_array.py             # [unix]
        - if not exist %SP_DIR%/pyarrow/tests/test_array.py exit 1  # [win]

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
Commit	Line	Data
1d09f67e TL	1	# NOTE: In constrast to the conda-forge recipe, ARROW_VERSION is a templated variable here.
	2	{% set version = ARROW_VERSION %}
	3	{% set cuda_enabled = cuda_compiler_version != "None" %}
	4	{% set build_ext_version = ARROW_VERSION %}
	5	{% set build_ext = "cuda" if cuda_enabled else "cpu" %}
	6	{% set proc_build_number = "0" %}
	7
	8	package:
	9	name: arrow-cpp-ext
	10	version: {{ version }}
	11
	12	source:
	13	path: ../../../../
	14
	15	build:
	16	number: 0
	17	# for cuda on win/linux, building with 9.2 is enough to be compatible with all later versions,
	18	# since arrow is only using libcuda, and not libcudart.
	19	skip: true # [(win or linux) and cuda_compiler_version not in ("None", "10.2")]
	20	skip: true # [osx and cuda_compiler_version != "None"]
	21	run_exports:
	22	- {{ pin_subpackage("arrow-cpp", max_pin="x.x.x") }}
	23
	24	outputs:
	25	- name: arrow-cpp-proc
	26	version: {{ build_ext_version }}
	27	build:
	28	number: {{ proc_build_number }}
	29	string: "{{ build_ext }}"
	30	test:
	31	commands:
	32	- exit 0
	33	about:
	34	home: http://github.com/apache/arrow
	35	license: Apache-2.0
	36	license_file:
	37	- LICENSE.txt
	38	summary: 'A meta-package to select Arrow build variant'
	39
	40	- name: arrow-cpp
	41	script: build-arrow.sh # [not win]
	42	script: bld-arrow.bat # [win]
	43	version: {{ version }}
	44	build:
	45	string: py{{ CONDA_PY }}h{{ PKG_HASH }}_{{ PKG_BUILDNUM }}_{{ build_ext }}
	46	run_exports:
	47	- {{ pin_subpackage("arrow-cpp", max_pin="x.x.x") }}
	48	ignore_run_exports:
	49	- cudatoolkit
	50	track_features:
	51	{{ "- arrow-cuda" if cuda_enabled else "" }}
	52	requirements:
	53	build:
	54	- python # [build_platform != target_platform]
	55	- cross-python_{{ target_platform }} # [build_platform != target_platform]
	56	- cython # [build_platform != target_platform]
	57	- numpy # [build_platform != target_platform]
	58	- gnuconfig # [osx and arm64]
	59	- libprotobuf
	60	- grpc-cpp
	61	- cmake
	62	- autoconf # [unix]
	63	- ninja
	64	- make # [unix]
65	- {{ compiler('c') }}
66	- {{ compiler('cxx') }}
67	- {{ compiler("cuda") }} # [cuda_compiler_version != "None"]
68	host:
69	- aws-sdk-cpp
70	- boost-cpp >=1.70
71	- brotli
72	- bzip2
73	- c-ares
74	- gflags
75	- glog
76	- grpc-cpp
77	- libprotobuf
78	- clangdev 10 # [not (osx and arm64)]
79	- llvmdev 10 # [not (osx and arm64)]
80	- libutf8proc
81	- lz4-c
82	- numpy
83	- orc # [unix]
84	- python
85	- rapidjson
86	- re2
87	- snappy
88	- thrift-cpp
89	- zlib
90	- zstd
91	run:
92	- {{ pin_compatible('numpy', lower_bound='1.16') }}
93	- python
94	run_constrained:
95	- arrow-cpp-proc * {{ build_ext }}
96	- cudatoolkit >=9.2 # [cuda_compiler_version != "None"]
97
98	about:
99	home: http://github.com/apache/arrow
100	license: Apache-2.0
101	license_file:
102	- LICENSE.txt
103	summary: C++ libraries for Apache Arrow
104
105	test:
106	commands:
107	# headers
108	- test -f $PREFIX/include/arrow/api.h # [unix]
109	- test -f $PREFIX/include/arrow/flight/types.h # [unix]
110	- test -f $PREFIX/include/plasma/client.h # [unix]
111	- test -f $PREFIX/include/gandiva/engine.h # [unix and not (osx and arm64)]
112	- test -f $PREFIX/include/parquet/api/reader.h # [unix]
113	- if not exist %LIBRARY_INC%\\arrow\\api.h exit 1 # [win]
114	- if not exist %LIBRARY_INC%\\gandiva\\engine.h exit 1 # [win]
115	- if not exist %LIBRARY_INC%\\parquet\\api\\reader.h exit 1 # [win]
116
117	# shared
118	- test -f $PREFIX/lib/libarrow.so # [linux]
119	- test -f $PREFIX/lib/libarrow_dataset.so # [linux]
120	- test -f $PREFIX/lib/libarrow_flight.so # [linux]
121	- test -f $PREFIX/lib/libarrow_python.so # [linux]
122	- test -f $PREFIX/lib/libparquet.so # [linux]
123	- test -f $PREFIX/lib/libgandiva.so # [linux]
124	- test -f $PREFIX/lib/libplasma.so # [linux]
125	- test -f $PREFIX/lib/libarrow_cuda${SHLIB_EXT} # [(cuda_compiler_version != "None") and unix]
126	- test ! -f $PREFIX/lib/libarrow_cuda${SHLIB_EXT} # [(cuda_compiler_version == "None") and unix]
127	- if not exist %PREFIX%\\Library\\bin\\arrow_cuda.dll exit 1 # [(cuda_compiler_version != "None") and win]
128	- if exist %PREFIX%\\Library\\bin\\arrow_cuda.dll exit 1 # [(cuda_compiler_version == "None") and win]
129	- test -f $PREFIX/lib/libarrow.dylib # [osx]
130	- test -f $PREFIX/lib/libarrow_dataset.dylib # [osx]
131	- test -f $PREFIX/lib/libarrow_python.dylib # [osx]
132	- test -f $PREFIX/lib/libgandiva.dylib # [osx and not arm64]
133	- test -f $PREFIX/lib/libparquet.dylib # [osx]
134	- test -f $PREFIX/lib/libplasma.dylib # [osx]
135	- if not exist %PREFIX%\\Library\\bin\\arrow.dll exit 1 # [win]
136	- if not exist %PREFIX%\\Library\\bin\\arrow_dataset.dll exit 1 # [win]
137	- if not exist %PREFIX%\\Library\\bin\\arrow_flight.dll exit 1 # [win]
138	- if not exist %PREFIX%\\Library\\bin\\arrow_python.dll exit 1 # [win]
139	- if not exist %PREFIX%\\Library\\bin\\parquet.dll exit 1 # [win]
140	- if not exist %PREFIX%\\Library\\bin\\gandiva.dll exit 1 # [win]
141
142	# absence of static libraries
143	- test ! -f $PREFIX/lib/libarrow.a # [unix]
144	- test ! -f $PREFIX/lib/libarrow_dataset.a # [unix]
145	- test ! -f $PREFIX/lib/libarrow_flight.a # [unix]
146	- test ! -f $PREFIX/lib/libarrow_python.a # [unix]
147	- test ! -f $PREFIX/lib/libplasma.a # [unix]
148	- test ! -f $PREFIX/lib/libparquet.a # [unix]
149	- test ! -f $PREFIX/lib/libgandiva.a # [unix]
150	- if exist %PREFIX%\\Library\\lib\\arrow_static.lib exit 1 # [win]
151	- if exist %PREFIX%\\Library\\lib\\arrow_dataset_static.lib exit 1 # [win]
152	- if exist %PREFIX%\\Library\\lib\\arrow_flight_static.lib exit 1 # [win]
153	- if exist %PREFIX%\\Library\\lib\\arrow_python_static.lib exit 1 # [win]
154	- if exist %PREFIX%\\Library\\lib\\parquet_static.lib exit 1 # [win]
155	- if exist %PREFIX%\\Library\\lib\\gandiva_static.lib exit 1 # [win]
156
157	- name: pyarrow
158	script: build-pyarrow.sh # [not win]
159	script: bld-pyarrow.bat # [win]
160	version: {{ version }}
161	build:
162	string: py{{ CONDA_PY }}h{{ PKG_HASH }}_{{ PKG_BUILDNUM }}_{{ build_ext }}
163	ignore_run_exports:
164	- cudatoolkit
165	track_features:
166	{{ "- arrow-cuda" if cuda_enabled else "" }}
167	requirements:
168	build:
169	- python # [build_platform != target_platform]
170	- cross-python_{{ target_platform }} # [build_platform != target_platform]
171	- cython # [build_platform != target_platform]
172	- numpy # [build_platform != target_platform]
173	- cmake
174	- ninja
175	- make # [unix]
176	- {{ compiler('c') }}
177	- {{ compiler('cxx') }}
178	# pyarrow does not require nvcc but it needs to link against libraries in arrow-cpp==cuda
179	- {{ compiler("cuda") }} # [cuda_compiler_version != "None"]
180	host:
181	- {{ pin_subpackage('arrow-cpp', exact=True) }}
182	- cython
183	- numpy
184	- python
185	- setuptools
186	- setuptools_scm
187	- six
188	run:
189	- {{ pin_subpackage('arrow-cpp', exact=True) }}
190	- {{ pin_compatible('numpy', lower_bound='1.16') }}
191	# empty parquet-cpp metapackage, force old versions to be uninstalled
192	- parquet-cpp 1.5.1.*
193	- python
194	run_constrained:
195	- arrow-cpp-proc * {{ build_ext }}
196	- cudatoolkit >=9.2 # [cuda_compiler_version != "None"]
197
198	about:
199	home: http://github.com/apache/arrow
200	license: Apache-2.0
201	license_file:
202	- LICENSE.txt
203	summary: Python libraries for Apache Arrow
204
205	test:
206	imports:
207	- pyarrow
208	- pyarrow.dataset
209	- pyarrow.flight
210	- pyarrow.gandiva # [not (osx and arm64)]
211	- pyarrow.orc # [unix]
212	- pyarrow.parquet
213	- pyarrow.plasma # [unix]
214	- pyarrow.fs
215	- pyarrow._s3fs
216	- pyarrow._hdfs
217	# We can only test importing cuda package but cannot run when a
218	# CUDA device is not available, for instance, when building from CI.
219	# On Windows, we cannot even do that due to `nvcuda.dll` not being found, see
220	# https://conda-forge.org/docs/maintainer/knowledge_base.html#nvcuda-dll-cannot-be-found-on-windows
221	# However, we check below for (at least) the presence of a correctly-compiled module
222	- pyarrow.cuda # [cuda_compiler_version != "None" and not win]
223	commands:
224	- test ! -f ${SP_DIR}/pyarrow/tests/test_array.py # [unix]
225	- if exist %SP_DIR%/pyarrow/tests/test_array.py exit 1 # [win]
226	# Need to remove dot from PY_VER; %MYVAR:x=y% replaces "x" in %MYVAR% with "y"
227	- if not exist %SP_DIR%/pyarrow/_cuda.cp%PY_VER:.=%-win_amd64.pyd exit 1 # [win and cuda_compiler_version != "None"]
228
229	- name: pyarrow-tests
230	script: build-pyarrow.sh # [not win]
231	script: bld-pyarrow.bat # [win]
232	version: {{ version }}
233	build:
234	string: py{{ CONDA_PY }}h{{ PKG_HASH }}_{{ PKG_BUILDNUM }}_{{ build_ext }}
235	ignore_run_exports:
236	- cudatoolkit
237	track_features:
238	{{ "- arrow-cuda" if cuda_enabled else "" }}
239	requirements:
240	build:
241	- python # [build_platform != target_platform]
242	- cross-python_{{ target_platform }} # [build_platform != target_platform]
243	- cython # [build_platform != target_platform]
244	- numpy # [build_platform != target_platform]
245	- cmake
246	- ninja
247	- make # [unix]
248	- {{ compiler('c') }}
249	- {{ compiler('cxx') }}
250	# pyarrow does not require nvcc but it needs to link against libraries in arrow-cpp==cuda
251	- {{ compiler("cuda") }} # [cuda_compiler_version != "None"]
252	host:
253	- {{ pin_subpackage('arrow-cpp', exact=True) }}
254	- {{ pin_subpackage('pyarrow', exact=True) }}
255	- cython
256	- numpy
257	- python
258	- setuptools
259	- setuptools_scm
260	- six
261	run:
262	- {{ pin_subpackage('pyarrow', exact=True) }}
263	- python
264	run_constrained:
265	- arrow-cpp-proc * {{ build_ext }}
266	- cudatoolkit >=9.2 # [cuda_compiler_version != "None"]
267
268	about:
269	home: http://github.com/apache/arrow
270	license: Apache-2.0
271	license_file:
272	- LICENSE.txt
273	summary: Python test files for Apache Arrow
274
275	test:
276	commands:
277	- test -f ${SP_DIR}/pyarrow/tests/test_array.py # [unix]
278	- if not exist %SP_DIR%/pyarrow/tests/test_array.py exit 1 # [win]
279
280	about:
281	home: http://github.com/apache/arrow
282	license: Apache-2.0
283	license_file:
284	- LICENSE.txt
285	summary: C++ and Python libraries for Apache Arrow
286
287	extra:
288	recipe-maintainers:
289	- wesm
290	- xhochy
291	- leifwalsh
292	- jreback
293	- cpcloud
294	- pcmoritz
295	- robertnishihara
296	- siddharthteotia
297	- kou
298	- kszucs
299	- pitrou
300	- pearu
301	- nealrichardson
302	- jakirkham