pyproject.toml

[build-system]
build-backend = 'setuptools.build_meta'
requires = ['setuptools>=65.5.0', 'wheel>=0.33.6', 'cython>=0.29.13']

# ---- Project description ----
# -- Standard options (PEP 621) --
[project]
authors = [{name = 'ETH Zurich', email = 'gridtools@cscs.ch'}]
classifiers = [
  'Development Status :: 4 - Beta',
  'Environment :: Console',
  'Environment :: GPU :: NVIDIA CUDA',
  'Intended Audience :: Science/Research',
  'License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)',
  'Operating System :: POSIX',
  'Programming Language :: Python',
  'Programming Language :: Python :: 3.8',
  'Programming Language :: Python :: 3.9',
  'Programming Language :: Python :: 3.10',
  'Programming Language :: Python :: 3.11',
  'Programming Language :: Python :: Implementation :: CPython',
  'Topic :: Scientific/Engineering :: Atmospheric Science',
  'Topic :: Scientific/Engineering :: Mathematics',
  'Topic :: Scientific/Engineering :: Physics'
]
dependencies = [
  "astunparse>=1.6.3;python_version<'3.9'",
  'attrs>=21.3',
  'black>=22.3',
  'boltons>=20.1',
  'cached-property>=1.5.1',
  'click>=8.0.0',
  'cmake>=3.22',
  'cytoolz>=0.12.1',
  'deepdiff>=5.6.0',
  'devtools>=0.6',
  'factory-boy>=3.3.0',
  'frozendict>=2.3',
  'gridtools-cpp>=2.3.2,==2.*',
  "importlib-resources>=5.0;python_version<'3.9'",
  'jinja2>=3.0.0',
  'lark>=1.1.2',
  'mako>=1.1',
  'nanobind>=1.4.0 ',
  'ninja>=1.10',
  'numpy>=1.23.3',
  'packaging>=20.0',
  'pybind11>=2.10.1',
  'setuptools>=65.5.0',
  'tabulate>=0.8.10',
  'typing-extensions>=4.10.0',
  'xxhash>=1.4.4,<3.1.0'
]
description = 'Python library for generating high-performance implementations of stencil kernels for weather and climate modeling from a domain-specific language (DSL)'
dynamic = ['version']
keywords = [
  'gridtools',
  'stencil',
  'weather',
  'climate',
  'performance',
  'portable',
  'hpc'
]
license = {text = 'GPL-3.0-or-later'}
name = 'gt4py'
readme = 'README.md'
requires-python = '>=3.8'

[project.optional-dependencies]
# Bundles
all-cpu = ['gt4py[dace,formatting,jax-cpu,performance,testing]']
all-cuda11 = ['gt4py[cuda11,dace,formatting,jax-cuda11,performance,testing]']
all-cuda12 = ['gt4py[cuda12,dace,formatting,jax-cuda12,performance,testing]']
# Other extras
cuda11 = ['cupy-cuda11x>=12.0']
cuda12 = ['cupy-cuda12x>=12.0']
dace = ['dace>=0.15.1,<0.16', 'sympy>=1.9']
formatting = ['clang-format>=9.0']
gpu = ['cupy>=12.0']
jax-cpu = ['jax[cpu]>=0.4.13']
jax-cuda11 = ['jax[cuda11_pip]>=0.4.13']
jax-cuda12 = ['jax[cuda12_pip]>=0.4.13']
performance = ['scipy>=1.9.2']
rocm-43 = ['cupy-rocm-4-3']
testing = ['hypothesis>=6.0.0', 'pytest>=7.0']

[project.scripts]
gtpyc = 'gt4py.cartesian.cli:gtpyc'

[project.urls]
Documentation = 'https://gridtools.github.io/gt4py'
Homepage = 'https://gridtools.github.io/'
Source = 'https://github.com/GridTools/gt4py'

# ---- Other tools ----
# -- bump-my-version --
[tool.bumpversion]
allow_dirty = false
commit = false
commit_args = ''
current_version = '1.0.3'
ignore_missing_version = false
message = 'Bump version: {current_version} → {new_version}'
parse = '(?P<major>\d+)\.(?P<minor>\d+)(\.(?P<patch>\d+))?'
regex = false
replace = '{new_version}'
search = '{current_version}'
serialize = ['{major}.{minor}.{patch}']
sign_tags = false
tag = false
tag_message = 'Bump version: {current_version} → {new_version}'
tag_name = 'v{new_version}'

[[tool.bumpversion.files]]
filename = "src/gt4py/__about__.py"

# -- coverage --
[tool.coverage]

[tool.coverage.html]
directory = 'tests/_reports/coverage_html'

[tool.coverage.paths]
source = ['src/', '.tox/py*/lib/python3.*/site-packages/']

[tool.coverage.report]
# Regexes for lines to exclude from consideration
exclude_lines = [
  'raise AssertionError',  # Don't complain if tests don't hit defensive assertion code
  'raise NotImplementedError',  # Don't complain if tests don't hit defensive assertion code
  'if 0:',  # Don't complain if non-runnable code isn't run
  'if __name__ == .__main__.:'  # Don't complain if non-runnable code isn't run
]
ignore_errors = true

[tool.coverage.run]
branch = true
source_pkgs = ['gt4py']

# -- mypy  --
[tool.mypy]
disallow_incomplete_defs = true
exclude = [
  '^setup\.py$',
  'build/.*$',
  'ci/*.$',
  'docs/.*$',
  'tests/.*$'
]
ignore_missing_imports = true
implicit_optional = false
implicit_reexport = false
install_types = true
namespace_packages = false
# pretty = true
show_column_numbers = true
show_error_codes = true
warn_redundant_casts = true
warn_unused_configs = true
warn_unused_ignores = true

# GT4Py configs
[[tool.mypy.overrides]]
allow_incomplete_defs = false
allow_untyped_defs = false
ignore_missing_imports = false
module = 'gt4py.*'

[[tool.mypy.overrides]]
# The following ignore_errors are only temporary.
# TODO: Fix errors and enable these settings.
allow_incomplete_defs = true
allow_untyped_defs = true
follow_imports = 'silent'
module = 'gt4py.cartesian.*'
warn_unused_ignores = false

[[tool.mypy.overrides]]
ignore_errors = true
module = 'gt4py.cartesian.backend.pyext_builder'

[[tool.mypy.overrides]]
ignore_errors = true
module = 'gt4py.cartesian.frontend.nodes'

[[tool.mypy.overrides]]
ignore_errors = true
module = 'gt4py.cartesian.frontend.node_util'

[[tool.mypy.overrides]]
ignore_errors = true
module = 'gt4py.cartesian.frontend.gtscript_frontend'

[[tool.mypy.overrides]]
ignore_errors = true
module = 'gt4py.cartesian.frontend.defir_to_gtir'

[[tool.mypy.overrides]]
ignore_errors = true
module = 'gt4py.cartesian.frontend.meta'

[[tool.mypy.overrides]]
module = 'gt4py.eve.extended_typing'
warn_unused_ignores = false

[[tool.mypy.overrides]]
# TODO: Make this false and fix errors
allow_untyped_defs = true
follow_imports = 'silent'
module = 'gt4py.storage.*'
warn_unused_ignores = false

[[tool.mypy.overrides]]
allow_incomplete_defs = true
allow_untyped_defs = true
module = 'gt4py.next.iterator.*'

[[tool.mypy.overrides]]
allow_incomplete_defs = true
allow_untyped_defs = true
module = 'gt4py.next.program_processors.runners.dace_iterator.*'

[[tool.mypy.overrides]]
ignore_errors = true
module = 'gt4py.next.ffront.decorator'

[[tool.mypy.overrides]]
ignore_errors = true
module = 'gt4py.next.iterator.runtime'

# -- pytest --
[tool.pytest]

[tool.pytest.ini_options]
markers = [
  'requires_atlas: tests that require `atlas4py` bindings package',
  'requires_dace: tests that require `dace` package',
  'requires_gpu: tests that require a NVidia GPU (`cupy` and `cudatoolkit` are required)',
  'uses_applied_shifts: tests that require backend support for applied-shifts',
  'uses_constant_fields: tests that require backend support for constant fields',
  'uses_dynamic_offsets: tests that require backend support for dynamic offsets',
  'uses_floordiv: tests that require backend support for floor division',
  'uses_if_stmts: tests that require backend support for if-statements',
  'uses_index_fields: tests that require backend support for index fields',
  'uses_lift_expressions: tests that require backend support for lift expressions',
  'uses_negative_modulo: tests that require backend support for modulo on negative numbers',
  'uses_origin: tests that require backend support for domain origin',
  'uses_reduction_over_lift_expressions: tests that require backend support for reduction over lift expressions',
  'uses_reduction_with_only_sparse_fields: tests that require backend support for with sparse fields',
  'uses_scan: tests that uses scan',
  'uses_scan_in_field_operator: tests that require backend support for scan in field operator',
  'uses_scan_without_field_args: tests that require calls to scan that do not have any fields as arguments',
  'uses_scan_nested: tests that use nested scans',
  'uses_scan_requiring_projector: tests need a projector implementation in gtfn',
  'uses_sparse_fields: tests that require backend support for sparse fields',
  'uses_sparse_fields_as_output: tests that require backend support for writing sparse fields',
  'uses_strided_neighbor_offset: tests that require backend support for strided neighbor offset',
  'uses_tuple_args: tests that require backend support for tuple arguments',
  'uses_tuple_returns: tests that require backend support for tuple results',
  'uses_zero_dimensional_fields: tests that require backend support for zero-dimensional fields',
  'uses_cartesian_shift: tests that use a Cartesian connectivity',
  'uses_unstructured_shift: tests that use a unstructured connectivity',
  'uses_max_over: tests that use the max_over builtin',
  'uses_mesh_with_skip_values: tests that use a mesh with skip values',
  'checks_specific_error: tests that rely on the backend to produce a specific error message'
]
norecursedirs = ['dist', 'build', 'cpp_backend_tests/build*', '_local/*', '.*']
testpaths = 'tests'

# -- ruff --
[tool.ruff]
line-length = 100  # It should be the same as in `tool.black.line-length` above
respect-gitignore = true
show-fixes = true
# show-source = true
target-version = 'py38'

[tool.ruff.format]
docstring-code-format = true

[tool.ruff.lint]
# # Rules sets:
# E: pycodestyle
# F: Pyflakes
# I: isort
# B: flake8-bugbear
# A: flake8-builtins
# T10: flake8-debugger
# ERA: eradicate
# NPY: NumPy-specific rules
# RUF: Ruff-specific rules
ignore = [
  'E501'  # [line-too-long]
]
ignore-init-module-imports = true
select = ['E', 'F', 'I', 'B', 'A', 'T10', 'ERA', 'NPY', 'RUF']
typing-modules = ['gt4py.eve.extended_typing']
unfixable = []

[tool.ruff.lint.isort]
combine-as-imports = true
# force-wrap-aliases = true
known-first-party = ['gt4py', '__externals__', '__gtscript__']
known-third-party = [
  'attr',
  'black',
  'boltons',
  'cached_property',
  'click',
  'cupy',
  'dace',
  'devtools',
  'factory',
  'hypothesis',
  'importlib_resources',
  'jinja2',
  'mako',
  'networkx',
  'numpy',
  'packaging',
  'pybind11',
  'pytest',
  'pytest_factoryboy',
  'setuptools',
  'tabulate',
  'typing_extensions',
  'xxhash'
]
lines-after-imports = 2
order-by-type = true
section-order = [
  'future',
  'standard-library',
  'third-party',
  'first-party',
  'tests',
  'local-folder'
]
split-on-trailing-comma = false

[tool.ruff.lint.isort.sections]
'tests' = ['cartesian_tests', 'eve_tests', 'next_tests', 'storage_tests']

[tool.ruff.lint.mccabe]
max-complexity = 15

[tool.ruff.lint.per-file-ignores]
'src/gt4py/cartesian/*' = ['RUF012']
'src/gt4py/eve/extended_typing.py' = ['F401', 'F405']
'src/gt4py/next/__init__.py' = ['F401']

# -- setuptools build backend --
[tool.setuptools]
platforms = ['Linux', 'Mac']

[tool.setuptools.dynamic]
version = {attr = 'gt4py.__about__.__version__'}

[tool.setuptools.package-data]
'*' = ['*.in', '*.txt']
'gt4py' = ['py.typed', '*.md', '*.rst']

[tool.setuptools.packages]
find = {namespaces = false, where = ['src']}