raptor-eagle 0.4.0__tar.gz

raptor_eagle-0.4.0/CMakeLists.txt

@@ -0,0 +1,344 @@
+# Copyright 2026 Alessandro Masat
+# SPDX-License-Identifier: Apache-2.0
+
+# Builds the eagle Python package's compiled artifacts (scikit-build-core):
+#
+#   eagle/_core.*.so       the nanobind module, one per Python version
+#   eagle/libeagle_cuda.so the CUDA backend plugin (eagle-backend/1 C seam),
+#                          no Python dependency: built ONCE and copied into every
+#                          per-Python wheel
+#
+# EAGLE_PYTHON_CUDA_PLUGIN selects where the plugin comes from:
+#   BUILD   (default) build it here with nvcc
+#   OFF     no plugin (the GPU-less leg); every CUDA entry point raises
+#           eagle.BackendUnavailable
+#   <path>  install that prebuilt libeagle_cuda.so (the per-Python phase)
+# EAGLE_PYTHON_SKIP_CORE=ON builds the plugin alone (phase 1, no Python needed).
+cmake_minimum_required(VERSION 3.20)
+project(eagle_python LANGUAGES CXX)
+
+set(EAGLE_PYTHON_CUDA_PLUGIN "BUILD" CACHE STRING
+    "Where libeagle_cuda.so comes from: BUILD | OFF | <path to a prebuilt plugin>")
+option(EAGLE_PYTHON_SKIP_CORE "Build only the CUDA plugin, not eagle._core" OFF)
+option(EAGLE_BACKEND_INJECT_MISSING
+    "Export one seam symbol under a wrong name (symbol-gate injection build only)" OFF)
+
+string(TOUPPER "${EAGLE_PYTHON_CUDA_PLUGIN}" _eagle_plugin_mode)
+if(NOT _eagle_plugin_mode STREQUAL "BUILD" AND NOT _eagle_plugin_mode STREQUAL "OFF")
+  set(_eagle_plugin_mode "PATH")
+  if(NOT EXISTS "${EAGLE_PYTHON_CUDA_PLUGIN}")
+    message(FATAL_ERROR
+      "EAGLE_PYTHON_CUDA_PLUGIN must be BUILD, OFF or the path of a prebuilt "
+      "libeagle_cuda.so; '${EAGLE_PYTHON_CUDA_PLUGIN}' does not exist")
+  endif()
+endif()
+if(EAGLE_PYTHON_SKIP_CORE AND NOT _eagle_plugin_mode STREQUAL "BUILD")
+  message(FATAL_ERROR "EAGLE_PYTHON_SKIP_CORE=ON builds nothing unless EAGLE_PYTHON_CUDA_PLUGIN=BUILD")
+endif()
+
+# Bundle libstdc++/libgcc when the toolchain has their static archives (the
+# wheel then loads in envs whose system libstdc++ predates the build
+# toolchain's GLIBCXX); a toolchain without them (a distribution gcc without
+# its libstdc++-static package) links them dynamically instead.
+include(CheckLinkerFlag)
+check_linker_flag(CXX "-static-libstdc++" EAGLE_STATIC_LIBSTDCXX)
+if(EAGLE_STATIC_LIBSTDCXX)
+  set(_eagle_static_runtime -static-libstdc++ -static-libgcc)
+else()
+  set(_eagle_static_runtime "")
+  message(WARNING "eagle: no static libstdc++ in this toolchain; linking it dynamically")
+endif()
+
+# Only the plugin needs the CUDA toolkit; the core is plain C++.
+if(_eagle_plugin_mode STREQUAL "BUILD")
+  # Pascal..Hopper SASS plus PTX at the OLDEST architecture, which every newer
+  # device can JIT -- of the architectures this nvcc still compiles (a newer
+  # toolkit drops the oldest: each is asked with a one-line compile). Override
+  # for a faster local build with a QUOTED list, e.g. -DCMAKE_CUDA_ARCHITECTURES=61.
+  if(NOT DEFINED CMAKE_CUDA_ARCHITECTURES)
+    set(_eagle_nvcc "${CMAKE_CUDA_COMPILER}")
+    if(NOT _eagle_nvcc)
+      find_program(_eagle_nvcc nvcc)
+    endif()
+    set(_eagle_archs "")
+    if(_eagle_nvcc)
+      set(_eagle_probe "${CMAKE_CURRENT_BINARY_DIR}/eagle_arch_probe.cu")
+      file(WRITE "${_eagle_probe}" "__global__ void k(float* x) { x[0] = 1.f; }\n")
+      foreach(_a 61 70 75 80 90 100)
+        execute_process(COMMAND "${_eagle_nvcc}" -c -arch=sm_${_a} "${_eagle_probe}"
+                        -o "${_eagle_probe}.${_a}.o"
+                        RESULT_VARIABLE _rc OUTPUT_QUIET ERROR_QUIET)
+        if(_rc EQUAL 0)
+          list(APPEND _eagle_archs ${_a})
+        endif()
+      endforeach()
+    endif()
+    if(NOT _eagle_archs)  # no nvcc to ask here: CMake finds the compiler later
+      set(_eagle_archs 61 70 80 90)
+    endif()
+    # the default set: Pascal, Volta, Ampere, Hopper (and the oldest a newer
+    # toolkit keeps, when it no longer compiles Pascal or Volta)
+    set(_eagle_wanted 61 70 80 90)
+    list(GET _eagle_archs 0 _eagle_oldest)
+    if(NOT _eagle_oldest IN_LIST _eagle_wanted)
+      list(INSERT _eagle_wanted 0 ${_eagle_oldest})
+    endif()
+    set(CMAKE_CUDA_ARCHITECTURES "")
+    foreach(_a IN LISTS _eagle_wanted)
+      if(_a IN_LIST _eagle_archs)
+        list(APPEND CMAKE_CUDA_ARCHITECTURES "${_a}-real")
+      endif()
+    endforeach()
+    if(NOT CMAKE_CUDA_ARCHITECTURES)
+      message(FATAL_ERROR "eagle: this nvcc (${_eagle_nvcc}) compiles none of sm_61..sm_100")
+    endif()
+    list(APPEND CMAKE_CUDA_ARCHITECTURES "${_eagle_oldest}-virtual")
+  endif()
+  enable_language(CUDA)
+  find_package(CUDAToolkit REQUIRED)
+endif()
+
+# eagle C++ headers (INTERFACE) + its aether/OpenMP deps.
+#
+# This binding lives INSIDE the eagle repo, so it must compile the eagle headers
+# that sit next to it. A bare find_package would resolve against whatever eagle
+# is installed in the ambient environment prefix, which on a dev box is easily a
+# a different (older) build — and the failure is SILENT: the wrong headers
+# compile perfectly and produce a binding missing the very feature being added.
+# Prefer a repo-local install of the tracked tree; the caller can still override
+# by passing -Deagle_DIR explicitly.
+if(NOT DEFINED eagle_DIR)
+  set(_eagle_tracked "${CMAKE_CURRENT_SOURCE_DIR}/../__install_p1/share/eagle/cmake")
+  if(EXISTS "${_eagle_tracked}/eagleConfig.cmake")
+    set(eagle_DIR "${_eagle_tracked}")
+  endif()
+endif()
+find_package(eagle CONFIG REQUIRED)
+
+# Prove the resolved eagle is recent enough to contain what this TU binds,
+# rather than discovering it at import time as a missing attribute. Keyed on the
+# header the binding actually needs; a stale install fails the configure loudly.
+get_target_property(_eagle_incs eagle::eagle INTERFACE_INCLUDE_DIRECTORIES)
+set(_eagle_root "")
+foreach(_dir IN LISTS _eagle_incs)
+  if(EXISTS "${_dir}/eagle/cuda/CaptureFork.h")
+    set(_eagle_root "${_dir}")
+    break()
+  endif()
+endforeach()
+if(NOT _eagle_root)
+  message(FATAL_ERROR
+    "The resolved eagle package does not provide eagle/cuda/CaptureFork.h.\n"
+    "  eagle_DIR                     = ${eagle_DIR}\n"
+    "  INTERFACE_INCLUDE_DIRECTORIES = ${_eagle_incs}\n"
+    "This binding must compile the TRACKED eagle headers. Install the tracked "
+    "tree to a prefix you own and pass -Deagle_DIR=<prefix>/share/eagle/cmake. "
+    "Never install into another environment's prefix.")
+endif()
+
+# Compile the LIVE tracked headers, not the installed copy. The install supplies
+# the package interface (compile definitions, flags, aether, and the eagle/plugin/
+# prefix that only exists post-install), but its headers are a SNAPSHOT: they go
+# stale the moment someone edits the tree, and the build then silently compiles
+# yesterday's sources — the same silent-staleness failure this whole block
+# exists to prevent, just relocated. Prepending the repo root makes
+# eagle/{cuda,util,cpu,...} resolve live; eagle/plugin/ has no in-tree
+# counterpart under that prefix, so it still falls through to the install.
+get_filename_component(_eagle_src "${CMAKE_CURRENT_SOURCE_DIR}/.." ABSOLUTE)
+if(EXISTS "${_eagle_src}/eagle/cuda/CaptureFork.h")
+  set_property(TARGET eagle::eagle PROPERTY
+    INTERFACE_INCLUDE_DIRECTORIES "${_eagle_src}" ${_eagle_incs})
+  set(_eagle_root "${_eagle_src} (live tree, ahead of ${_eagle_root})")
+endif()
+message(STATUS "> eagle headers (verified to contain CaptureFork.h): ${_eagle_root}")
+
+# Both artifacts carry eagle/aether inline and template instantiations; a
+# STB_GNU_UNIQUE copy of one would bind across the two images at load time.
+set(_eagle_no_gnu_unique
+  $<$<COMPILE_LANGUAGE:CXX>:-fno-gnu-unique>
+  $<$<COMPILE_LANGUAGE:CUDA>:-Xcompiler=-fno-gnu-unique>)
+
+# ---------------------------------------------------------------------------
+# libeagle_cuda.so — the CUDA backend plugin.
+#
+# Driver API only: no CUDA runtime is linked (CUDA_RUNTIME_LIBRARY None). The
+# runtime calls eagle's headers make are implemented over the driver by
+# src/plugin/cuda_driver.cpp, which opens libcuda.so.1 at run time, so the only
+# CUDA library the plugin ever loads is the driver's. The plugin's own kernels
+# are compiled ahead of time into the embedded fat binary (the arch list above)
+# and loaded with cuModuleLoadData. Hidden visibility and a version script
+# export the eagle_backend_* C seam and nothing else; libstdc++/libgcc are
+# bundled so the plugin loads next to any core. It is dlopen'd by eagle._core
+# (src/seam/Loader.h), never linked, so nothing else may depend on it.
+# --no-undefined turns a runtime call the translation layer does not implement
+# into a link error instead of a load-time failure.
+# ---------------------------------------------------------------------------
+if(_eagle_plugin_mode STREQUAL "BUILD")
+  add_library(eagle_cuda SHARED src/plugin/eagle_cuda.cu src/plugin/cuda_driver.cpp)
+  target_compile_features(eagle_cuda PRIVATE cxx_std_20)
+  target_include_directories(eagle_cuda PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/src")
+  # Headers only (cuda.h, cudaTypedefs.h, cuda_runtime_api.h); nothing from the
+  # toolkit is linked.
+  target_include_directories(eagle_cuda SYSTEM PRIVATE ${CUDAToolkit_INCLUDE_DIRS})
+  target_link_libraries(eagle_cuda PRIVATE eagle::eagle ${CMAKE_DL_LIBS})
+  string(REPLACE ";" "," _eagle_plugin_archs "${CMAKE_CUDA_ARCHITECTURES}")
+  target_compile_definitions(eagle_cuda PRIVATE
+    EAGLE_PYTHON_VERSION="${eagle_VERSION}"
+    EAGLE_CUDA_PLUGIN_ARCHS="${_eagle_plugin_archs}"
+    $<$<BOOL:${EAGLE_BACKEND_INJECT_MISSING}>:EAGLE_BACKEND_INJECT_MISSING=1>)
+  target_compile_options(eagle_cuda PRIVATE ${_eagle_no_gnu_unique})
+  set(_eagle_map "${CMAKE_CURRENT_SOURCE_DIR}/src/plugin/eagle_cuda.map")
+  target_link_options(eagle_cuda PRIVATE
+    "LINKER:--version-script=${_eagle_map}" "LINKER:--no-undefined" ${_eagle_static_runtime})
+  set_target_properties(eagle_cuda PROPERTIES
+    OUTPUT_NAME eagle_cuda
+    # Link through the C++ driver (the one carrying the static libstdc++), not
+    # nvcc's host compiler.
+    LINKER_LANGUAGE CXX
+    LINK_DEPENDS "${_eagle_map}"
+    CUDA_RUNTIME_LIBRARY None
+    CUDA_VISIBILITY_PRESET "hidden"
+    CXX_VISIBILITY_PRESET "hidden"
+    POSITION_INDEPENDENT_CODE ON
+    # One TU, whole-program device compilation: a relocatable (-rdc) build is
+    # device-linked to SASS only, which would drop the 90-virtual PTX the arch
+    # list asks for (JIT on newer GPUs). Nothing here needs device linking.
+    CUDA_SEPARABLE_COMPILATION OFF)
+  install(TARGETS eagle_cuda LIBRARY DESTINATION eagle)
+  message(STATUS "> libeagle_cuda.so: built here (archs ${CMAKE_CUDA_ARCHITECTURES})")
+elseif(_eagle_plugin_mode STREQUAL "PATH")
+  install(FILES "${EAGLE_PYTHON_CUDA_PLUGIN}" DESTINATION eagle RENAME libeagle_cuda.so)
+  message(STATUS "> libeagle_cuda.so: prebuilt ${EAGLE_PYTHON_CUDA_PLUGIN}")
+else()
+  message(STATUS "> libeagle_cuda.so: NOT included (EAGLE_PYTHON_CUDA_PLUGIN=OFF)")
+endif()
+
+if(EAGLE_PYTHON_SKIP_CORE)
+  message(STATUS "> eagle._core: NOT built (EAGLE_PYTHON_SKIP_CORE=ON)")
+  return()
+endif()
+
+# ---------------------------------------------------------------------------
+# eagle._core — the nanobind module.
+# ---------------------------------------------------------------------------
+
+# Python + nanobind from the building interpreter (scikit-build-core provides it;
+# the --cmake_dir fallback also covers a plain `cmake` invocation).
+find_package(Python 3.9 REQUIRED COMPONENTS Interpreter Development.Module)
+find_package(nanobind CONFIG QUIET)
+if(NOT nanobind_FOUND)
+  execute_process(
+    COMMAND "${Python_EXECUTABLE}" -m nanobind --cmake_dir
+    OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE nanobind_ROOT)
+  find_package(nanobind CONFIG REQUIRED PATHS "${nanobind_ROOT}" NO_DEFAULT_PATH)
+endif()
+
+# The core is plain C++ (EAGLE_CPU_ONLY + AETHER_CPP_MODE): it reaches CUDA only
+# through the plugin, so it needs no CUDA toolkit to build and no driver to load.
+# It takes the eagle/aether HEADERS only — not eagle::eagle / aether::aether, whose
+# exported definitions describe the CUDA-mode package (AETHER_HAS_CUDA, ...).
+find_package(OpenMP REQUIRED COMPONENTS CXX)
+get_target_property(_eagle_core_incs eagle::eagle INTERFACE_INCLUDE_DIRECTORIES)
+get_target_property(_aether_incs aether::aether INTERFACE_INCLUDE_DIRECTORIES)
+nanobind_add_module(_core MODULE src/eagle_core.cpp)
+target_compile_features(_core PRIVATE cxx_std_23)
+# aether's own include directories first: an installed eagle's prefix may also
+# hold an (older) aether copy, and the aether this configure resolved must win.
+target_include_directories(_core PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/src" ${_aether_incs} ${_eagle_core_incs})
+target_compile_definitions(_core PRIVATE EAGLE_CPU_ONLY=1 AETHER_CPP_MODE=1 EAGLE_BLOCKSIZE=256 NDEBUG)
+target_link_libraries(_core PRIVATE OpenMP::OpenMP_CXX ${CMAKE_DL_LIBS})
+target_compile_options(_core PRIVATE ${_eagle_no_gnu_unique})
+# libstdc++/libgcc bundled where the toolchain allows (see _eagle_static_runtime).
+target_link_options(_core PRIVATE ${_eagle_static_runtime})
+set_target_properties(_core PROPERTIES
+  CXX_VISIBILITY_PRESET "hidden"
+  POSITION_INDEPENDENT_CODE ON
+  LINKER_LANGUAGE CXX)
+# The wall, asserted where it is decided: no CUDA source reaches the core.
+get_target_property(_core_sources _core SOURCES)
+foreach(_src IN LISTS _core_sources)
+  if(_src MATCHES "\\.cu$")
+    message(FATAL_ERROR "eagle._core must stay CUDA-free; it lists the CUDA source ${_src}")
+  endif()
+endforeach()
+
+# scikit-build-core maps this DESTINATION into the wheel's eagle package.
+install(TARGETS _core LIBRARY DESTINATION eagle)
+
+# ---------------------------------------------------------------------------
+# eagle._mpi — the OPTIONAL second extension: eagle::exec::RankPartition.
+#
+# WHY IT IS A SECOND MODULE. `eagle/exec/RankPartition.h` refuses to compile
+# without `EAGLE_MPI`, and that define exists so eagle never links libmpi: the C++
+# side puts it PRIVATELY on one test target and nowhere else. Putting the rank
+# surface into `_core` would drag libmpi into the extension every eagle user
+# imports — including everyone with no MPI installed, for whom `import eagle`
+# would simply stop working. `_core` stays MPI-free (an audit row in the Python
+# suite reads its `ldd`), and the rank structure lives here, built only where an
+# MPI is present.
+#
+# EAGLE_PYTHON_MPI is TRI-STATE, not a bool, because "off" and "not available"
+# must stay distinguishable: ON demands an MPI and FAILS THE CONFIGURE without
+# one (a silently skipped module is how a CI job certifies a surface it never
+# built), OFF never looks, and AUTO builds it iff MPI is found. Either way this
+# block prints what it decided — a build whose optional half quietly vanished is
+# the thing the STATUS line exists to prevent.
+# ---------------------------------------------------------------------------
+set(EAGLE_PYTHON_MPI "AUTO" CACHE STRING
+    "Build the optional eagle._mpi extension (eagle::exec::RankPartition): ON | OFF | AUTO")
+set_property(CACHE EAGLE_PYTHON_MPI PROPERTY STRINGS ON OFF AUTO)
+string(TOUPPER "${EAGLE_PYTHON_MPI}" _eagle_python_mpi)
+
+if(_eagle_python_mpi STREQUAL "OFF")
+  message(STATUS "> eagle._mpi: NOT built (EAGLE_PYTHON_MPI=OFF)")
+elseif(_eagle_python_mpi STREQUAL "ON" OR _eagle_python_mpi STREQUAL "AUTO")
+  if(_eagle_python_mpi STREQUAL "ON")
+    find_package(MPI REQUIRED COMPONENTS CXX)
+  else()
+    find_package(MPI QUIET COMPONENTS CXX)
+  endif()
+  if(NOT MPI_CXX_FOUND)
+    message(STATUS "> eagle._mpi: NOT built (EAGLE_PYTHON_MPI=AUTO and no MPI found); "
+                   "eagle.exec.RankPartition will refuse, naming the rule")
+  else()
+    message(STATUS "> eagle._mpi: building against MPI ${MPI_CXX_VERSION} (${MPI_CXX_COMPILER})")
+
+    # The library path the module re-opens RTLD_GLOBAL before MPI_Init, so Open
+    # MPI's dlopen'ed MCA components can resolve against it (a Python extension is
+    # loaded RTLD_LOCAL; see promoteMpiSymbols() in src/eagle_mpi.cpp). Resolved
+    # HERE from what MPI::MPI_CXX actually carries — never a guessed SONAME. An
+    # imported-target-only MPI leaves it empty and the module skips the promotion.
+    set(_eagle_mpi_library "")
+    foreach(_lib IN LISTS MPI_CXX_LIBRARIES)
+      if(_lib MATCHES "libmpi\\.(so|dylib)")
+        set(_eagle_mpi_library "${_lib}")
+        break()
+      endif()
+    endforeach()
+    message(STATUS "> eagle._mpi: RTLD_GLOBAL promotion target = "
+                   "'${_eagle_mpi_library}'")
+
+    # Plain C++ like _core (its device inner forwards to the CUDA backend).
+    nanobind_add_module(_mpi MODULE src/eagle_mpi.cpp)
+    target_compile_features(_mpi PRIVATE cxx_std_23)
+    target_include_directories(_mpi PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/src"
+      "${CMAKE_CURRENT_SOURCE_DIR}/.." ${_aether_incs} ${_eagle_core_incs})
+    # EAGLE_MPI is PRIVATE to this target, exactly as it is on the C++ bed: it is
+    # what makes RankPartition.h compile at all, and it must not leak to anything
+    # else in the build.
+    target_compile_definitions(_mpi PRIVATE
+      EAGLE_CPU_ONLY=1 AETHER_CPP_MODE=1 EAGLE_BLOCKSIZE=256 NDEBUG
+      EAGLE_MPI=1 EAGLE_MPI_LIBRARY="${_eagle_mpi_library}")
+    target_link_libraries(_mpi PRIVATE OpenMP::OpenMP_CXX MPI::MPI_CXX ${CMAKE_DL_LIBS})
+    target_compile_options(_mpi PRIVATE ${_eagle_no_gnu_unique})
+    # The same wheel-portability link flags `_core` carries, for the same reason.
+    target_link_options(_mpi PRIVATE ${_eagle_static_runtime})
+    set_target_properties(_mpi PROPERTIES
+      CXX_VISIBILITY_PRESET "hidden"
+      POSITION_INDEPENDENT_CODE ON)
+    install(TARGETS _mpi LIBRARY DESTINATION eagle)
+  endif()
+else()
+  message(FATAL_ERROR
+    "EAGLE_PYTHON_MPI must be ON, OFF or AUTO; got '${EAGLE_PYTHON_MPI}'")
+endif()

raptor_eagle-0.4.0/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed 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.

raptor_eagle-0.4.0/NOTICE

@@ -0,0 +1,2 @@
+eagle
+Copyright 2026 Alessandro Masat