gdalcubes 0.1.0.dev0__tar.gz

gdalcubes-0.1.0.dev0/.github/workflows/test.yml

@@ -0,0 +1,37 @@
+name: tests
+
+on:
+  push:
+    branches: [main, master]
+  pull_request:
+
+jobs:
+  test:
+    name: ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install native dependencies (Linux)
+        if: runner.os == 'Linux'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libgdal-dev libnetcdf-dev libsqlite3-dev libcurl4-openssl-dev
+
+      - name: Install native dependencies (macOS)
+        if: runner.os == 'macOS'
+        run: brew install gdal netcdf
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Build and install
+        run: pip install -v .[test,xarray,tif,stac]
+
+      - name: Run tests
+        run: pytest -v

gdalcubes-0.1.0.dev0/.github/workflows/wheels.yml

@@ -0,0 +1,176 @@
+# Binary wheels with the full GDAL stack vendored (no system dependencies for
+# users), following the pyogrio/rasterio approach: native libraries come from
+# vcpkg (see vcpkg.json), wheels are repaired with auditwheel / delocate /
+# delvewheel to bundle the shared libraries, and GDAL/PROJ data files are
+# installed into the package (see GDALCUBES_*_DATA in CMakeLists.txt).
+#
+# NOTE: this workflow is the heavy part of the project and is expected to need
+# iteration in CI (GDAL feature flags, library search paths per platform).
+
+name: wheels
+
+on:
+  push:
+    tags: ["v*"]
+  workflow_dispatch:
+
+env:
+  VCPKG_COMMIT: "1de2026f28ead93ff1773e6e680387643e914ea1"  # pin; update deliberately
+
+jobs:
+  build_wheels:
+    name: ${{ matrix.os }}-${{ matrix.arch }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-latest
+            arch: x86_64
+            triplet: x64-linux-dynamic
+          - os: ubuntu-24.04-arm
+            arch: aarch64
+            triplet: arm64-linux-dynamic
+          - os: macos-13
+            arch: x86_64
+            triplet: x64-osx-dynamic
+          - os: macos-14
+            arch: arm64
+            triplet: arm64-osx-dynamic
+          - os: windows-latest
+            arch: AMD64
+            triplet: x64-windows
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Cache vcpkg
+        uses: actions/cache@v4
+        with:
+          path: |
+            vcpkg
+            vcpkg_installed
+          key: vcpkg-${{ env.VCPKG_COMMIT }}-${{ matrix.os }}-${{ matrix.triplet }}-${{ hashFiles('vcpkg.json') }}
+
+      - name: Bootstrap vcpkg and install dependencies (macOS / Windows)
+        if: runner.os != 'Linux'
+        shell: bash
+        run: |
+          if [ ! -d vcpkg ]; then
+            git clone https://github.com/microsoft/vcpkg.git
+            git -C vcpkg checkout ${{ env.VCPKG_COMMIT }}
+            ./vcpkg/bootstrap-vcpkg.sh -disableMetrics
+          fi
+          ./vcpkg/vcpkg install --triplet ${{ matrix.triplet }}
+
+      - name: Build wheels
+        uses: pypa/cibuildwheel@v2
+        env:
+          CIBW_BUILD: "cp310-* cp311-* cp312-* cp313-*"
+          CIBW_ARCHS: ${{ matrix.arch }}
+          CIBW_SKIP: "*-musllinux*"
+
+          # Linux builds run inside the manylinux container: bootstrap vcpkg there
+          CIBW_BEFORE_ALL_LINUX: >
+            yum install -y curl zip unzip tar perl-IPC-Cmd flex bison &&
+            git clone https://github.com/microsoft/vcpkg.git /opt/vcpkg &&
+            git -C /opt/vcpkg checkout ${{ env.VCPKG_COMMIT }} &&
+            /opt/vcpkg/bootstrap-vcpkg.sh -disableMetrics &&
+            VCPKG_FORCE_SYSTEM_BINARIES=1 /opt/vcpkg/vcpkg install
+            --x-manifest-root=/project --triplet ${{ matrix.triplet }}
+            --x-install-root=/project/vcpkg_installed
+
+          CIBW_ENVIRONMENT_LINUX: >
+            VCPKG_ROOT=/opt/vcpkg
+            VCPKG_PREFIX=/project/vcpkg_installed/${{ matrix.triplet }}
+            CMAKE_PREFIX_PATH=/project/vcpkg_installed/${{ matrix.triplet }}
+            LD_LIBRARY_PATH=/project/vcpkg_installed/${{ matrix.triplet }}/lib
+          CIBW_ENVIRONMENT_MACOS: >
+            VCPKG_PREFIX=$PWD/vcpkg_installed/${{ matrix.triplet }}
+            CMAKE_PREFIX_PATH=$PWD/vcpkg_installed/${{ matrix.triplet }}
+            DYLD_LIBRARY_PATH=$PWD/vcpkg_installed/${{ matrix.triplet }}/lib
+            MACOSX_DEPLOYMENT_TARGET=${{ matrix.os == 'macos-14' && '14.0' || '13.0' }}
+          CIBW_ENVIRONMENT_WINDOWS: >
+            VCPKG_PREFIX=$GITHUB_WORKSPACE/vcpkg_installed/${{ matrix.triplet }}
+            CMAKE_PREFIX_PATH=$GITHUB_WORKSPACE/vcpkg_installed/${{ matrix.triplet }}
+
+          CIBW_CONFIG_SETTINGS: >
+            cmake.define.GDALCUBES_GDAL_DATA=${VCPKG_PREFIX}/share/gdal
+            cmake.define.GDALCUBES_PROJ_DATA=${VCPKG_PREFIX}/share/proj
+
+          # bundle shared libraries into the wheel
+          CIBW_REPAIR_WHEEL_COMMAND_LINUX: >
+            LD_LIBRARY_PATH=/project/vcpkg_installed/${{ matrix.triplet }}/lib
+            auditwheel repair -w {dest_dir} {wheel}
+          CIBW_REPAIR_WHEEL_COMMAND_MACOS: >
+            DYLD_LIBRARY_PATH=$PWD/vcpkg_installed/${{ matrix.triplet }}/lib
+            delocate-wheel --require-archs {delocate_archs} -w {dest_dir} {wheel}
+          CIBW_BEFORE_BUILD_WINDOWS: pip install delvewheel
+          CIBW_REPAIR_WHEEL_COMMAND_WINDOWS: >
+            delvewheel repair
+            --add-path %VCPKG_PREFIX%\bin
+            -w {dest_dir} {wheel}
+
+          CIBW_TEST_REQUIRES: pytest numpy
+          CIBW_TEST_COMMAND: pytest {project}/tests -v
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: wheels-${{ matrix.os }}-${{ matrix.arch }}
+          path: wheelhouse/*.whl
+
+  # WebAssembly wheel for Pyodide (see tools/wasm/README.md)
+  build_pyodide:
+    name: pyodide
+    runs-on: ubuntu-latest
+    env:
+      PYODIDE_VERSION: "314.0.7"
+    steps:
+      - uses: actions/checkout@v4
+
+      # the Pyodide build tools must run on the Python the release targets
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.14"
+
+      # cmake and ninja from PyPI, so the job does not depend on the runner image
+      - name: Prepare native dependencies
+        run: |
+          pip install pyodide-cli pyodide-build cmake ninja
+          tools/wasm/build.sh --deps-only
+
+      - name: Build wheel
+        uses: pypa/cibuildwheel@v4.3.1
+        env:
+          CIBW_PLATFORM: pyodide
+          CIBW_BUILD: "cp314-*"
+          CIBW_PYODIDE_VERSION: ${{ env.PYODIDE_VERSION }}
+
+          # global data in the bundled libraries is only reachable when exported
+          CIBW_ENVIRONMENT_PYODIDE: PYODIDE_BUILD_EXPORTS=requested
+
+          # bundle libgdal, libproj and libgeos into the wheel
+          CIBW_REPAIR_WHEEL_COMMAND_PYODIDE: >
+            pyodide auditwheel repair {wheel}
+            --libdir {project}/build/wasm/deps/lib
+            --output-dir {dest_dir}
+
+          # the test data is DEFLATE-compressed, which Pyodide GDAL cannot
+          # decode, so only the tests on synthetic cubes run here
+          CIBW_TEST_REQUIRES: pytest numpy
+          CIBW_TEST_COMMAND: python -m pytest {project}/tests/test_chunks.py -k "not unreadable"
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: wheels-pyodide
+          path: wheelhouse/*.whl
+
+  build_sdist:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - run: pipx run build --sdist
+      - uses: actions/upload-artifact@v4
+        with:
+          name: sdist
+          path: dist/*.tar.gz

gdalcubes-0.1.0.dev0/.gitignore

@@ -0,0 +1,222 @@
+### C++ ###
+# Prerequisites
+*.d
+
+# Compiled Object files
+*.slo
+*.lo
+*.o
+*.obj
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Compiled Dynamic libraries
+*.so
+*.dylib
+*.dll
+
+# Fortran module files
+*.mod
+*.smod
+
+# Compiled Static libraries
+*.lai
+*.la
+*.a
+*.lib
+
+# Executables
+*.exe
+*.out
+*.app
+
+### Python ###
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+### Python Patch ###
+# Poetry local configuration file - https://python-poetry.org/docs/configuration/#local-configuration
+poetry.toml
+
+# ruff
+.ruff_cache/
+
+# LSP config files
+pyrightconfig.json
+
+# Extras
+wheelhouse/
+compile_commands.json
+.DS_Store
+_resources/
+
+# Outputs produced by the example scripts in examples/
+L8_Amazon.zip
+L8_Amazon/
+L8.db
+ndvi.nc
+ndvi_tifs/
+rgb_median.nc
+rgb_composite.png
+s2_ndvi.nc
+s2_regularized/
+l8_regularized/

gdalcubes-0.1.0.dev0/CMakeLists.txt

@@ -0,0 +1,125 @@
+cmake_minimum_required(VERSION 3.18)
+project(gdalcubes_py LANGUAGES CXX C)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+if(NOT CMAKE_BUILD_TYPE)
+    set(CMAKE_BUILD_TYPE Release)
+endif()
+
+find_package(Python 3.10 COMPONENTS Interpreter Development.Module REQUIRED)
+
+execute_process(
+    COMMAND "${Python_EXECUTABLE}" -m nanobind --cmake_dir
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+    OUTPUT_VARIABLE nanobind_ROOT
+)
+find_package(nanobind CONFIG REQUIRED)
+
+# native dependencies (same set as the core's own build) ---
+if(EMSCRIPTEN)
+    # Pyodide: GDAL is the libgdal shared library Pyodide ships, with headers
+    # generated from the same GDAL release. SQLite comes from libgdal, curl is a stub
+    # (the browser has no sockets), and netcdf is a static classic-format build
+    set(WASM_DEPS_DIR "${CMAKE_CURRENT_SOURCE_DIR}/build/wasm/deps"
+        CACHE PATH "include/, lib/ and share/ prepared by tools/wasm/build.sh")
+    
+    if(NOT EXISTS "${WASM_DEPS_DIR}/lib/libgdal.so")
+        message(FATAL_ERROR "no dependencies in ${WASM_DEPS_DIR}: run tools/wasm/build.sh --deps-only")
+    endif()
+
+    # the GDAL and PROJ data the script prepared go into the wheel by default
+    set(GDALCUBES_GDAL_DATA "${WASM_DEPS_DIR}/share/gdal" CACHE PATH "GDAL data directory to bundle into the wheel")
+    set(GDALCUBES_PROJ_DATA "${WASM_DEPS_DIR}/share/proj" CACHE PATH "PROJ data directory to bundle into the wheel")
+    add_library(wasm_deps INTERFACE)
+    
+    # Boost.Regex is header-only, and standalone mode needs no other Boost
+    # netcdf is classic-only here (no HDF5), so the core writes classic files
+    target_compile_definitions(wasm_deps INTERFACE BOOST_REGEX_STANDALONE USE_NCDF4=0)
+    target_include_directories(wasm_deps INTERFACE
+        ${WASM_DEPS_DIR}/include
+        ${WASM_DEPS_DIR}/include/gdal
+    )
+    target_link_libraries(wasm_deps INTERFACE
+        ${WASM_DEPS_DIR}/lib/libgdal.so
+        ${WASM_DEPS_DIR}/lib/libnetcdf.a
+    )
+    
+    set(NETCDF_INCLUDE_DIR ${WASM_DEPS_DIR}/include)
+
+else()
+    find_package(GDAL REQUIRED)
+    find_package(CURL REQUIRED)
+    find_package(SQLite3 REQUIRED)
+
+    find_path(NETCDF_INCLUDE_DIR "netcdf.h" HINTS $ENV{NETCDF_INCLUDEDIR})
+    find_library(NETCDF_LIBRARY netcdf HINTS $ENV{NETCDF_LIBDIR})
+    if(NOT NETCDF_INCLUDE_DIR OR NOT NETCDF_LIBRARY)
+        message(FATAL_ERROR "netcdf C library not found (set NETCDF_INCLUDEDIR / NETCDF_LIBDIR)")
+    endif()
+endif()
+
+# vendored gdalcubes core
+set(CORE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/src/gdalcubes)
+file(GLOB CORE_SOURCES ${CORE_DIR}/*.cpp)
+
+list(APPEND CORE_SOURCES
+    ${CORE_DIR}/external/tinyexpr/tinyexpr.c
+    ${CORE_DIR}/external/json11/json11.cpp
+    ${CORE_DIR}/external/tiny-process-library/process.cpp
+)
+
+if(WIN32)
+    list(APPEND CORE_SOURCES ${CORE_DIR}/external/tiny-process-library/process_win.cpp)
+else()
+    list(APPEND CORE_SOURCES ${CORE_DIR}/external/tiny-process-library/process_unix.cpp)
+endif()
+
+# the binding layer is split by concern into several translation units
+file(GLOB BINDING_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/src/bindings/*.cpp)
+nanobind_add_module(_core ${BINDING_SOURCES} ${CORE_SOURCES})
+
+target_compile_definitions(_core PRIVATE GDALCUBES_NO_SWARM)
+
+# The vendored core uses std::shared_ptr in some headers (e.g. progress_virt.h)
+# without including <memory>. libc++ (macOS) pulls it in transitively, but
+# libstdc++ (Linux/GCC) does not, so those translation units fail to compile.
+# Force-include <memory> for every C++ unit (not the C sources like tinyexpr.c,
+# where <memory> does not exist) instead of patching the vendored sources, which
+# tools/sync_core.sh would overwrite on the next re-vendor.
+if(MSVC)
+    target_compile_options(_core PRIVATE $<$<COMPILE_LANGUAGE:CXX>:/FImemory>)
+else()
+    target_compile_options(_core PRIVATE "$<$<COMPILE_LANGUAGE:CXX>:SHELL:-include memory>")
+endif()
+
+target_include_directories(_core PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}/src
+    ${NETCDF_INCLUDE_DIR}
+)
+
+if(EMSCRIPTEN)
+    # SQLite is not compiled in: libgdal and libproj each export one, and the
+    # loader binds symbols across modules, so a second copy here gets mixed with
+    # theirs. The core uses the copy they export.
+    target_link_libraries(_core PRIVATE wasm_deps)
+else()
+    target_link_libraries(
+        _core PRIVATE GDAL::GDAL CURL::libcurl SQLite::SQLite3 ${NETCDF_LIBRARY}
+    )
+endif()
+
+install(TARGETS _core LIBRARY DESTINATION gdalcubes)
+
+# wheel builds bundle the GDAL/PROJ runtime data files into the package.
+# gdalcubes/__init__.py points GDAL_DATA / PROJ_DATA at them when present
+set(GDALCUBES_GDAL_DATA "" CACHE PATH "GDAL data directory to bundle into the wheel")
+set(GDALCUBES_PROJ_DATA "" CACHE PATH "PROJ data directory to bundle into the wheel")
+
+if(GDALCUBES_GDAL_DATA)
+    install(DIRECTORY ${GDALCUBES_GDAL_DATA}/ DESTINATION gdalcubes/gdal_data)
+endif()
+
+if(GDALCUBES_PROJ_DATA)
+    install(DIRECTORY ${GDALCUBES_PROJ_DATA}/ DESTINATION gdalcubes/proj_data)
+endif()

gdalcubes-0.1.0.dev0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Felipe Carlos
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.