nind 2.0.3__tar.gz

nind-2.0.3/.github/workflows/docker-publish.yml

@@ -0,0 +1,94 @@
+name: Docker
+
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+
+on:
+  schedule:
+    - cron: '19 8 * * *'
+  push:
+    branches: [ master ]
+    # Publish semver tags as releases.
+    tags: [ 'v*.*.*' ]
+  pull_request:
+    branches: [ master ]
+
+env:
+  # Use docker.io for Docker Hub if empty
+  REGISTRY: ghcr.io
+  # github.repository as <account>/<repo>
+  IMAGE_NAME: ${{ github.repository }}
+
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+      # This is used to complete the identity challenge
+      # with sigstore/fulcio when running outside of PRs.
+      id-token: write
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v2
+
+      # Install the cosign tool except on PR
+      # https://github.com/sigstore/cosign-installer
+      - name: Install cosign
+        if: github.event_name != 'pull_request'
+        uses: sigstore/cosign-installer@1e95c1de343b5b0c23352d6417ee3e48d5bcd422
+        with:
+          cosign-release: 'v1.4.0'
+
+
+      # Workaround: https://github.com/docker/build-push-action/issues/461
+      - name: Setup Docker buildx
+        uses: docker/setup-buildx-action@79abd3f86f79a9d68a23c75a09a9a85889262adf
+
+      # Login against a Docker registry except on PR
+      # https://github.com/docker/login-action
+      - name: Log into registry ${{ env.REGISTRY }}
+        if: github.event_name != 'pull_request'
+        uses: docker/login-action@28218f9b04b4f3f62068d7b6ce6ca5b26e35336c
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      # Extract metadata (tags, labels) for Docker
+      # https://github.com/docker/metadata-action
+      - name: Extract Docker metadata
+        id: meta
+        uses: docker/metadata-action@98669ae865ea3cffbcbaa878cf57c20bbf1c6c38
+        with:
+          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
+
+      # Build and push Docker image with Buildx (don't push on PR)
+      # https://github.com/docker/build-push-action
+      - name: Build and push Docker image
+        id: build-and-push
+        uses: docker/build-push-action@ad44023a93711e3deb337508980b4b5e9bcdc5dc
+        with:
+          context: .
+          file: Dockerfile-debian11
+          push: ${{ github.event_name != 'pull_request' }}
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+
+      # Sign the resulting Docker image digest except on PRs.
+      # This will only write to the public Rekor transparency log when the Docker
+      # repository is public to avoid leaking data.  If you would like to publish
+      # transparency data even for private images, pass --force to cosign below.
+      # https://github.com/sigstore/cosign
+      - name: Sign the published Docker image
+        if: ${{ github.event_name != 'pull_request' }}
+        env:
+          COSIGN_EXPERIMENTAL: "true"
+        # This step uses the identity token to provision an ephemeral certificate
+        # against the sigstore community Fulcio instance.
+        run: cosign sign ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}@${{ steps.build-and-push.outputs.digest }}

nind-2.0.3/.github/workflows/publish-pypi.yml

@@ -0,0 +1,116 @@
+name: Publish Python package
+
+# Builds the `nind` wheel (with its compiled nind._native extension) for
+# Linux/macOS/Windows plus an sdist, then publishes them to PyPI.
+#
+# Triggered by pushing a version tag, which `bumpver update` creates and
+# pushes automatically (see [tool.bumpver] in pyproject.toml) - so a release
+# is just:
+#   uvx bumpver update --patch   # or --minor / --major
+#
+# PyPI auth is via Trusted Publishing (OIDC): no stored secret, but the repo
+# must first be registered as a trusted publisher for the `nind` project at
+# https://pypi.org/manage/project/nind/settings/publishing/ pointing at this
+# workflow file and the `pypi` environment used below.
+
+on:
+  push:
+    tags:
+      - 'v*.*.*'
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    name: Run Python test suite
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+
+      - name: Run tests
+        run: uv run pytest tst/py -v
+
+  build_wheels:
+    name: Build wheels (${{ matrix.os }})
+    needs: test
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-14, windows-latest]
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      # cibuildwheel's own uv auto-provisioning isn't reliable on every
+      # platform (seen failing with "uv not found" on macOS/Windows); putting
+      # a real uv on PATH first avoids depending on that.
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+
+      - name: Build wheels
+        uses: pypa/cibuildwheel@v4.2.1
+        env:
+          CIBW_BUILD: "cp3*"
+          CIBW_SKIP: "*-musllinux*"
+          CIBW_BUILD_FRONTEND: "uv"
+          CIBW_ARCHS_MACOS: "auto"
+          # cibuildwheel's default also builds 32-bit (win32) wheels; nobody
+          # targets 32-bit Windows Python for this, and it's a strictly worse
+          # environment for the LLP64-vs-LP64 "long is 32-bit" class of bugs.
+          CIBW_ARCHS_WINDOWS: "AMD64"
+
+      - name: Upload wheels
+        uses: actions/upload-artifact@v4
+        with:
+          name: wheels-${{ matrix.os }}
+          path: wheelhouse/*.whl
+
+  build_sdist:
+    name: Build source distribution
+    needs: test
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+
+      - name: Build sdist
+        run: uv build --sdist
+
+      - name: Upload sdist
+        uses: actions/upload-artifact@v4
+        with:
+          name: sdist
+          path: dist/*.tar.gz
+
+  publish:
+    name: Publish to PyPI
+    needs: [build_wheels, build_sdist]
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/nind
+    permissions:
+      id-token: write
+    steps:
+      - name: Download built distributions
+        uses: actions/download-artifact@v4
+        with:
+          pattern: '*'
+          path: dist
+          merge-multiple: true
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+
+      - name: Publish to PyPI
+        run: uv publish --trusted-publishing always

nind-2.0.3/.gitignore

@@ -0,0 +1,5 @@
+*.kdev4
+build/
+*~
+*.pyc
+Dist*/

nind-2.0.3/.travis.yml

@@ -0,0 +1,76 @@
+sudo: required
+language: cpp
+cache: ccache
+branches:
+  except:
+  - "/^\\d\\d\\d\\d\\d\\d\\d\\d\\d\\d\\d\\d\\d\\d-[\\da-f]+$/"
+env:
+  global:
+  - secure: FlsmywHiGR6VKejCGcEd59rhvk5YI1f+FUAWfBLVxzqG4haLGT0MQwyxDr2EPS3Iu+v16nsMxHT2dwMCotC8zTPSmHUr6evE4jpNcqs+vIOAz7VLjdqwD0jweeguOR4JxL1XcgFZMAPTnoQFBFZlEOFu8OxaDjOoG7Oj0iGH+Fo=
+  - secure: 89MWEONx9hRT4aMMxqTcwHVfErXx7lYuL2jirVk5qhdZhJ7GzuOgd/FjDNhyJmZxy77BcYe60vvvPsRwjst1XOUKLQ35QnIaGcN29GVhZksyW1K0qSqRr/gjf+2yDLuqZZ/OmCHDEzoNaKD3BC+weKA5J2j4qmeBEB05HKOAVZQ=
+  - USE_TENSORFLOW=false
+services:
+- docker
+jobs:
+  include:
+  - stage: test
+    script: docker build --tag ubuntu18.04 --build-arg JOB_NUMBER=$TRAVIS_JOB_NUMBER
+      -f ./Dockerfile-ubuntu18.04 . && docker run -t -d ubuntu18.04 && docker cp $(docker
+      ps -n 1 -q):/usr/share/apps/nind/packages/ $HOME && ls $HOME/packages/
+    before_deploy: git config --local user.name "Gael de Chalendar" git config --local
+      user.email "kleagg@gmail.com" git tag "$(git log --date=iso  -1 | grep Date
+      | sed -e 's/Date:\ *//' -e 's/\+.*//' -e 's/[- :]//g')-$(git log --format=%h
+      --abbrev=8 -1)" || true
+    deploy:
+      provider: releases
+      api_key:
+        secure: YBHi+kyNbnpWb4/P1apH06nwvUWhe9mnu1E08jN898DaKSCXhuss7JiLuaP5ogWAlRcGVHAO/9ntC91WWryfYp+qSDudrOZu7AQFvIpHAfE8WX8G6bGov74+sjA5YptdKaQ1QyAg2D2JfsghdPwR9JSqYaeSqVRYSs0P/GlnZw0cNgCWVIOMgv4wJZ8IpTMItSlHu4CVqgDMfcCivylhyUP9kccqD7itPaxUgOhD2ftAjdPf8eJoPdr7jpvWwGDiv0kwDoDGBUR1HPc3XT8/Vr5CX7Yy0AhTEgPzWcTbp6+Njw5MzttfEQaUXpdVKlJnmgBYJ8Fn/8tXpnySsGvcozwD29O7mHWB68f91m5ZKMQFDWwXpJ95m45MLIi4UzSYqUNUSTREnAI0o75+vcPNodETwpFPYvWgwQzgQIIsuw+svIvjtBYNKVLsJCoBuxCjFcwMXXD7Hug4vkx9v2RIjK4zn9AU/P8605uh03Ht/gKfJ8WGY5iND0+aVm7M6vPPuK1iCoWpOsI8Rayw5NP1Sj+AbK5ysrcO0ytnKfKFhzuZLq/0t6yDcsKjQeWxPNSbiIDIpYDigqJYHcA8yWJREGe3biFq/+T+He1BcATV1+FSMPMojnJ4xEvnvIYUTwsULwh7jCTTuevdcWVqiTcE5kP9V9Jn9ZEmXuHbDXPJ7tA=
+      file_glob: true
+      file: "$HOME/packages/*.deb"
+      skip_cleanup: true
+      on:
+        repo: aymara/nind
+        tags: false
+        branches:
+          except:
+          - "/^\\d\\d\\d\\d\\d\\d\\d\\d\\d\\d\\d\\d\\d\\d-[\\da-f]+$/"
+  - script: docker build --tag ubuntu16.04 --build-arg JOB_NUMBER=$TRAVIS_JOB_NUMBER
+      -f ./Dockerfile-ubuntu16.04 . && docker run -t -d ubuntu16.04 && docker cp $(docker
+      ps -n 1 -q):/usr/share/apps/nind/packages/ $HOME && ls $HOME/packages/
+    before_deploy: git config --local user.name "Gael de Chalendar" git config --local
+      user.email "kleagg@gmail.com" git tag "$(git log --date=iso  -1 | grep Date
+      | sed -e 's/Date:\ *//' -e 's/\+.*//' -e 's/[- :]//g')-$(git log --format=%h
+      --abbrev=8 -1)" || true
+    deploy:
+      provider: releases
+      api_key:
+        secure: YBHi+kyNbnpWb4/P1apH06nwvUWhe9mnu1E08jN898DaKSCXhuss7JiLuaP5ogWAlRcGVHAO/9ntC91WWryfYp+qSDudrOZu7AQFvIpHAfE8WX8G6bGov74+sjA5YptdKaQ1QyAg2D2JfsghdPwR9JSqYaeSqVRYSs0P/GlnZw0cNgCWVIOMgv4wJZ8IpTMItSlHu4CVqgDMfcCivylhyUP9kccqD7itPaxUgOhD2ftAjdPf8eJoPdr7jpvWwGDiv0kwDoDGBUR1HPc3XT8/Vr5CX7Yy0AhTEgPzWcTbp6+Njw5MzttfEQaUXpdVKlJnmgBYJ8Fn/8tXpnySsGvcozwD29O7mHWB68f91m5ZKMQFDWwXpJ95m45MLIi4UzSYqUNUSTREnAI0o75+vcPNodETwpFPYvWgwQzgQIIsuw+svIvjtBYNKVLsJCoBuxCjFcwMXXD7Hug4vkx9v2RIjK4zn9AU/P8605uh03Ht/gKfJ8WGY5iND0+aVm7M6vPPuK1iCoWpOsI8Rayw5NP1Sj+AbK5ysrcO0ytnKfKFhzuZLq/0t6yDcsKjQeWxPNSbiIDIpYDigqJYHcA8yWJREGe3biFq/+T+He1BcATV1+FSMPMojnJ4xEvnvIYUTwsULwh7jCTTuevdcWVqiTcE5kP9V9Jn9ZEmXuHbDXPJ7tA=
+      file_glob: true
+      file: "$HOME/packages/*.deb"
+      skip_cleanup: true
+      on:
+        repo: aymara/nind
+        tags: false
+        branches:
+          except:
+          - "/^\\d\\d\\d\\d\\d\\d\\d\\d\\d\\d\\d\\d\\d\\d-[\\da-f]+$/"
+  - script: docker build --tag debian9.4 --build-arg JOB_NUMBER=$TRAVIS_JOB_NUMBER
+      -f ./Dockerfile-debian9.4 . && docker run -t -d debian9.4 && docker cp $(docker
+      ps -n 1 -q):/usr/share/apps/nind/packages/ $HOME && ls $HOME/packages/
+    before_deploy: git config --local user.name "Gael de Chalendar" git config --local
+      user.email "kleagg@gmail.com" git tag "$(git log --date=iso  -1 | grep Date
+      | sed -e 's/Date:\ *//' -e 's/\+.*//' -e 's/[- :]//g')-$(git log --format=%h
+      --abbrev=8 -1)" || true
+    deploy:
+      provider: releases
+      api_key:
+        secure: YBHi+kyNbnpWb4/P1apH06nwvUWhe9mnu1E08jN898DaKSCXhuss7JiLuaP5ogWAlRcGVHAO/9ntC91WWryfYp+qSDudrOZu7AQFvIpHAfE8WX8G6bGov74+sjA5YptdKaQ1QyAg2D2JfsghdPwR9JSqYaeSqVRYSs0P/GlnZw0cNgCWVIOMgv4wJZ8IpTMItSlHu4CVqgDMfcCivylhyUP9kccqD7itPaxUgOhD2ftAjdPf8eJoPdr7jpvWwGDiv0kwDoDGBUR1HPc3XT8/Vr5CX7Yy0AhTEgPzWcTbp6+Njw5MzttfEQaUXpdVKlJnmgBYJ8Fn/8tXpnySsGvcozwD29O7mHWB68f91m5ZKMQFDWwXpJ95m45MLIi4UzSYqUNUSTREnAI0o75+vcPNodETwpFPYvWgwQzgQIIsuw+svIvjtBYNKVLsJCoBuxCjFcwMXXD7Hug4vkx9v2RIjK4zn9AU/P8605uh03Ht/gKfJ8WGY5iND0+aVm7M6vPPuK1iCoWpOsI8Rayw5NP1Sj+AbK5ysrcO0ytnKfKFhzuZLq/0t6yDcsKjQeWxPNSbiIDIpYDigqJYHcA8yWJREGe3biFq/+T+He1BcATV1+FSMPMojnJ4xEvnvIYUTwsULwh7jCTTuevdcWVqiTcE5kP9V9Jn9ZEmXuHbDXPJ7tA=
+      file_glob: true
+      file: "$HOME/packages/*.deb"
+      skip_cleanup: true
+      on:
+        repo: aymara/nind
+        tags: false
+        branches:
+          except:
+          - "/^\\d\\d\\d\\d\\d\\d\\d\\d\\d\\d\\d\\d\\d\\d-[\\da-f]+$/"

nind-2.0.3/AGENTS.md

@@ -0,0 +1,32 @@
+# AGENTS.md - Nind Indexing Module
+
+## Developer Commands
+
+### Build
+Requires `NIND_DIST` environment variable to be set.
+- Default build: `NIND_DIST=/path/to/dist ./gbuild.sh`
+- Address Sanitizer: `./gbuild.sh -a ON`
+- Native architecture optimizations: `./gbuild.sh -n native`
+- Linear build (disable parallel): `./gbuild.sh -p false`
+- Change build mode: `./gbuild.sh -m Release` or `./gbuild.sh -m RelWithDebInfo`
+- Change CMake generator: `./gbuild.sh -G Unix` (default is `Ninja`)
+
+### Verification
+- Build and test (via `gbuild.sh` if generator supports it): `./gbuild.sh`
+- Manual test execution: `ctest` within the build directory (`build/<branch>/<mode>/nind`)
+
+## Architecture & Conventions
+
+- **Language**: C++ (targets C++14, falls back to C++11/0x).
+- **Build System**: CMake.
+- **Project Structure**:
+  - `src/`: Core implementation.
+  - `tst/`: Test suites (mostly in `tst/cpp/`).
+- **Debug Mode**: The `-DDEBUG_NIND` flag is automatically added in `Debug` and `RelWithDebInfo` modes to enable debug output.
+- **Binary Format**: Nind uses an EBNF grammar to specify binary file formats. These are verified by Python programs (not in this repo's main source but referenced in README).
+
+## Toolchain Quirks
+
+- **NIND_DIST**: This variable is mandatory for `gbuild.sh` to define the installation prefix.
+- **Build Artifacts**: Builds are isolated by branch and mode in `build/<branch>/<mode>/nind`.
+- **Linker Flags**: Uses `-Wl,-z,defs,--no-as-needed` to support a plugin mechanism where symbols must remain visible even if not explicitly used.

nind-2.0.3/CLAUDE.md

@@ -0,0 +1,107 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project overview
+
+NIND ("nouvelle indexation") is a flat-file inverted-index module originally built for the `Amose` search engine (replacing the deprecated `S2` and `Lucene` indexers). It has two parallel implementations of the same binary formats:
+
+- **C++** (`src/cpp/`): the production indexing/search libraries.
+- **Python** (`src/py/nind/`): a pure-Python re-implementation used both as a standalone frontend and, per the original design intent, to independently verify the C++ binary output against the format's EBNF grammar (no shared code between the two — they are two independent readers/writers of the same file formats).
+
+The repo is mid-refactor (branch `refactoring-for-codecommons`): the Python package was recently moved from `src/py/*.py` into a proper `src/py/nind/` package, and a new higher-level `nind_engine.py` (BM25-style search API) is being layered on top of the low-level Python classes.
+
+The `nind` wheel additionally bundles a compiled extension, `nind._native` (pybind11 bindings over the core C++ index stack — `NindLexiconIndex`, `NindTermIndex`, `NindLocalIndex`, `NindRetrolexicon`, `NindLexicon`). This does *not* change the cross-verification design above: the pure-Python classes remain independent readers/writers with no shared code, and `nind._native` is an optional third, native code path (full read/write, unlike the read-only pure-Python classes) — see `src/cpp/NindPy/`.
+
+## Build & test — C++
+
+Requires the `NIND_DIST` env var (install prefix). Build via the wrapper script, not raw `cmake`/`make` directly:
+
+```
+NIND_DIST=/path/to/dist ./gbuild.sh              # Debug build (default), builds + runs ctest + installs
+./gbuild.sh -m Release                            # Release or RelWithDebInfo
+./gbuild.sh -a ON                                 # with AddressSanitizer (+ UB/leak sanitizers where supported)
+./gbuild.sh -n native                             # -march=native instead of generic tuning
+./gbuild.sh -p false                              # disable parallel build (build with -j1)
+./gbuild.sh -G Unix                               # use Unix Makefiles instead of Ninja
+```
+
+Build artifacts land in `build/<git-branch>/<mode>/<project>` (isolated per branch/mode, so switching branches doesn't require a clean).
+
+To run tests manually instead of via the full `gbuild.sh` cycle: `ctest` from inside that build directory (only applies to generators that produce a `make test`/ctest target, e.g. `Unix Makefiles`; Ninja builds skip the automatic test step in `gbuild.sh`).
+
+`-DDEBUG_NIND` is added automatically in `Debug` and `RelWithDebInfo` modes (and in `Release` if configured with `-DWITH_DEBUG_MESSAGES=ON`) to enable conditional debug output.
+
+## Build & test — Python
+
+The Python package (`nind`, in `src/py/nind`) is managed with `pyproject.toml`/`scikit-build-core` (the old `src/py/CMakeLists.txt` build path is kept only for compatibility). `uv sync`/`uv build` compiles `nind._native` (via CMake — see `src/cpp/NindPy/CMakeLists.txt`) and installs the package (editable for `sync`) plus dev dependencies (pytest) into `.venv`. Building requires a C++14 compiler; `scikit-build-core`, `pybind11`, `cmake`, and `ninja` themselves are all pulled automatically as PEP 517 build requirements (the latter two so builds work even in containers with no system CMake/Ninja, e.g. manylinux in CI) — no manual install needed.
+
+Tests live in `tst/py/` (one file per module, mirroring `tst/cpp/unit/`), configured via `[tool.pytest.ini_options]` in `pyproject.toml`:
+
+```
+uv sync                 # first time / after touching pyproject.toml or src/cpp/NindPy/**
+uv run pytest tst/py -v
+uv build                 # produce the platform wheel (nind-*.whl) + sdist in dist/
+```
+
+`src/cpp/NindPy/CMakeLists.txt` is a standalone CMake project (separate from the top-level `CMakeLists.txt`/`gbuild.sh` flow) that compiles the relevant `NindBasics`/`NindRetrolexicon`/`NindLexicon`/`NindIndex` sources directly into the `_native` extension module — not linked against the shared libraries `gbuild.sh` produces — so the wheel ships one self-contained `.so` with no internal RPATH/dlopen. It is not wired into `gbuild.sh`/ctest; touching the core C++ sources may require rebuilding both independently.
+
+Verification of the Python readers/writers against the C++-produced binary files (the project's original EBNF-grammar cross-check design, see README) isn't automated yet — the current suite validates the Python implementation against itself (round-trips through `nind_engine.NindIndexer`'s writers, plus hand-built fixtures for formats it doesn't write, like `.nindretrolexicon`).
+
+### Releasing
+
+Version bumps are managed by `bumpver` (config: `[tool.bumpver]` in `pyproject.toml`) — it keeps `current_version` (git-tag form, `vX.Y.Z`) and the PEP 440 form in sync everywhere it appears: `[project] version` in `pyproject.toml` and every `__version__ = "..."` across `src/py/nind/`. Cutting a release is:
+
+```
+uvx bumpver update --patch    # or --minor / --major; add --dry to preview first
+```
+
+This commits, tags (`vX.Y.Z`), and *pushes* in one step (`push = true` in config) — pushing the tag is what kicks off `.github/workflows/publish-pypi.yml`, which builds wheels for Linux/macOS/Windows (via `cibuildwheel`, using `uv` as its build frontend) plus an sdist (`uv build --sdist`), and publishes them to PyPI with `uv publish --trusted-publishing always`. That workflow authenticates via PyPI Trusted Publishing (OIDC) against the `pypi` GitHub Environment — no stored token — but this only works once the `nind` PyPI project has that repo+workflow+environment registered as a trusted publisher (pypi.org project settings → Publishing); until then the `publish` job's `id-token` exchange will fail.
+
+## Architecture
+
+### C++ library layering (`src/cpp/`)
+
+Each subdirectory builds one shared library; dependencies flow strictly downward (see each module's `CMakeLists.txt` `target_link_libraries`):
+
+```
+NindBasics   (no deps)      — NindFile: buffered binary sequential file I/O; NindPadFile: ident <-> data mapping on top of it
+   ^
+   ├── NindRetrolexicon     — flat-file reverse lexicon (id -> string)
+   ├── NindLexicon          — in-memory lexicon (asymmetric maps), NindLexiconFile for its on-disk form
+   │
+NindIndex (deps: NindBasics, NindRetrolexicon)
+   — NindLexiconIndex/NindLexiconIndexK: lexicon as an index file (K variant uses two 32-bit keys instead of strings)
+   — NindTermIndex: the inverted file itself, as an index file
+   — NindLocalIndex: per-document local index file
+   — NindIndex: ties the above into a full inverted/local index file
+
+NindAmose (deps: NindIndex, NindRetrolexicon)
+   — adapts nind to Amose's richer term-type model (see internal doc refs "LAT2015.JYS.448")
+
+NindPy (deps: NindBasics, NindRetrolexicon, NindLexicon, NindIndex sources, compiled in directly)
+   — pybind11 bindings, built only through the Python wheel (scikit-build-core), not gbuild.sh
+```
+
+All C++ code lives in namespace `latecon::nindex`. Class/file naming mirrors the binary format they implement (e.g. `NindLexiconIndex` reads/writes the `.nindlexiconindex` file format) — this naming convention holds across both the C++ and Python trees, so a class name tells you both its role and its file extension.
+
+Design docs are referenced by internal report codes in file header comments (e.g. `LAT2014.JYS.440` = "nind, indexation post-S2", `LAT2015.JYS.448` = "Adaptation de l'indexation nind au moteur de recherche Amose") — these aren't in the repo, so treat the header comments above each class as the closest available spec.
+
+Linker flags (`-Wl,-z,defs,--no-as-needed`) are set project-wide because these libraries are loaded dynamically via a plugin/factory mechanism, so symbols must stay visible even when not directly referenced by the linking binary — don't "clean up" apparently-unused exports without checking for this.
+
+`tst/cpp/` mirrors the module structure for test binaries, but note `tst/cpp/CMakeLists.txt` currently only builds `NindIndex`, `NindSearch`, and `NindAmose` tests — the `NindLexicon`, `NindTests`, and `NindBasics` test subdirectories are commented out.
+
+### Python package (`src/py/nind/`)
+
+Parallels the C++ layering with lowercase-suffixed module names for the index classes:
+
+- `NindFile.py` — low-level binary codec. Historically read-only-oriented (the `litXxx` getters have long existed for every format), but now has a full writer counterpart too: `ejcritNombre1/3/4/5`, `ejcritNombreULat`/`ejcritNombreSLat` (both varint encodings, full tier range matching the readers and the C++ implementation), `ejcritChaine`, `ejcritZejros`.
+- `NindPadFile.py` — the shared "pad file" envelope (header, indirection block(s), specifics, identification trailer); read-only, no writer (mirrors `NindBasics::NindPadFile`, but nothing in Python subclasses it as a writer the way `NindIndex`/`NindRetrolexicon` do in C++).
+- `NindRetrolexicon.py`, `NindLexiconindex.py`, `NindTermindex.py`, `NindLocalindex.py` — read-only mirrors of the corresponding `NindIndex`-family C++ classes; `NindLexiconindex` is hash-bucketed (`clefB(word) % nombreIndirection`), the other two are directly indexed by id.
+- `nind_engine.py` — `NindIndexer` (writer) and `NindEngine` (BM25-style search) built on top of the above. `NindIndexer` is the *only* Python writer for the index-family formats (`.nindlexiconindex`/`.nindtermindex`/`.nindlocalindex`) — it hand-rolls the binary layout directly via `NindFile`, replicating what `NindPadFile`/`NindIndex` do in C++, since there's no Python writer class to build on. It does not write `.nindretrolexicon` (not needed by `NindEngine`, which only supports simple, non-compound words).
+- `Nind_*.py` at the package root — standalone CLI scripts (dump a document, convert corpora, search, diagnostics)
+- `amose/` — Amose-specific conversion/parsing scripts (Lucene dump, XML-CLEF, sample corpora)
+
+## Binary format verification
+
+Binary file formats are specified in EBNF grammar (see README). The intended workflow is: C++ writes the files, Python (independently implementing the same grammar) reads/checks them — this is why the Python and C++ implementations must be kept in sync at the file-format level even though they share no code.

nind-2.0.3/CMakeLists.txt

@@ -0,0 +1,146 @@
+project(nind)
+cmake_minimum_required(VERSION 3.5)
+
+option(WITH_ASAN "Enable address sanitizer" OFF)
+message("WITH_ASAN=${WITH_ASAN}")
+option(WITH_ARCH "Enable architecture optimizations" OFF)
+message("WITH_ARCH=${WITH_ARCH}")
+option(WITH_DEBUG_MESSAGES "Enable debug messages" OFF)
+message("WITH_DEBUG_MESSAGES=${WITH_DEBUG_MESSAGES}")
+
+include(SystemSpecificInformations.cmake)
+
+
+message("System name is ${CMAKE_SYSTEM_NAME}")
+if (NOT (${CMAKE_SYSTEM_NAME} STREQUAL "Windows"))
+    message("Linux flags")
+
+    # In debug mode, adds the -DDEBUG_INDEX to the compiler command line.
+    # Allows to build with conditionally built debug output
+    set(DEBUG_FLAGS "-DDEBUG_NIND")
+    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${DEBUG_FLAGS}" )
+    set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} ${DEBUG_FLAGS}" )
+    if (WITH_DEBUG_MESSAGES)
+      set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${DEBUG_FLAGS}" )
+    endif()
+
+    if (WITH_ARCH)
+      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=native")
+    else()
+      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mtune=generic -msse4.2")
+    endif()
+
+    # Flags needed for the plugins mechanism to work: our libs are dynamically loaded by
+    # factories, thus their symbols must be known even if not used by the binary
+    set(CMAKE_EXE_LINKER_FLAGS "-Wl,-z,defs,--no-as-needed")
+    set(CMAKE_SHARED_LINKER_FLAGS "-Wl,-z,defs,--no-as-needed")
+    set(CMAKE_MODULE_LINKER_FLAGS "-Wl,-z,defs,--no-as-needed")
+
+    include(CheckCXXCompilerFlag)
+    CHECK_CXX_COMPILER_FLAG(-std=c++0x HAVE_STDCPP0X)
+    CHECK_CXX_COMPILER_FLAG(-std=c++11 HAVE_STDCPP11)
+    CHECK_CXX_COMPILER_FLAG(-std=c++14 HAVE_STDCPP14)
+    CHECK_CXX_COMPILER_FLAG(-fsanitize=undefined HAVE_SANITIZE_UNDEFINED)
+    CHECK_CXX_COMPILER_FLAG(-fno-omit-frame-pointer HAVE_NO_OMIT_FRAME_POINTER)
+    if (HAVE_NO_OMIT_FRAME_POINTER)
+      set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fno-omit-frame-pointer")
+    endif()
+
+    if (HAVE_STDCPP14)
+      message("C++14 supported ")
+      set(CMAKE_CXX_STANDARD 14)
+      set(CMAKE_CXX_STANDARD_REQUIRED ON)
+      set(CMAKE_CXX_EXTENSIONS OFF)
+    elseif (HAVE_STDCPP11)
+      message("C++11 supported")
+      set(CMAKE_CXX_FLAGS "-std=c++11 -DBOOST_NO_HASH ${CMAKE_CXX_FLAGS}")
+      CHECK_CXX_COMPILER_FLAG(-Wsuggest-override HAVE_SUGGEST_OVERRIDE)
+      if (HAVE_SUGGEST_OVERRIDE)
+#       set(CMAKE_CXX_FLAGS "-Wsuggest-override -Werror=suggest-override ${CMAKE_CXX_FLAGS}")
+        set(CMAKE_CXX_FLAGS "-Wsuggest-override ${CMAKE_CXX_FLAGS}")
+      endif()
+    elseif (HAVE_STDCPP0X)
+      message("C++0x supported")
+      set(CMAKE_CXX_FLAGS "-std=c++0x -DBOOST_NO_HASH ${CMAKE_CXX_FLAGS}")
+    else ()
+      message("C++0x NOT supported")
+      set(CMAKE_CXX_FLAGS "-DNO_STDCPP0X ${CMAKE_CXX_FLAGS}")
+    endif ()
+    set(CMAKE_CXX_FLAGS "-W -Wall ${CMAKE_CXX_FLAGS}")
+
+    if (WITH_ASAN)
+      # NOTE: check -fsanitize=address flag failed if this flag is not set also
+      # for the linker (use CMAKE_REQUIRED_FLAGS to set linker flag for 
+      # CHECK_CXX_COMPILER_FLAG macro).
+      set(SAFE_CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS}")
+      set(CMAKE_REQUIRED_FLAGS "-fsanitize=address")
+      CHECK_CXX_COMPILER_FLAG(-fsanitize=address HAVE_SANITIZE_ADDRESS)
+      set(CMAKE_REQUIRED_FLAGS "${SAFE_CMAKE_REQUIRED_FLAGS}")
+      if (HAVE_SANITIZE_ADDRESS)
+        set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fsanitize=address")
+      endif()
+      CHECK_CXX_COMPILER_FLAG(-fsanitize=undefined HAVE_SANITIZE_UNDEFINED)
+      if (HAVE_SANITIZE_UNDEFINED)
+        set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fsanitize=undefined")
+      endif()
+      CHECK_CXX_COMPILER_FLAG(-fsanitize=leak HAVE_SANITIZE_LEAK)
+      if (HAVE_SANITIZE_LEAK)
+        set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fsanitize=leak")
+      endif()
+    endif ()
+
+    set(LIB_INSTALL_DIR "lib")
+else ()
+  message("Windows flags")
+  add_definitions(-D WIN32)
+  
+  # By default, do not warn when built on machines using only VS Express:
+  if (NOT DEFINED CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS_NO_WARNINGS)
+    set(CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS_NO_WARNINGS ON)
+  endif ()
+
+  set(CMAKE_C_FLAGS "/Zc:wchar_t- /EHsc /GR ${CMAKE_C_FLAGS}")
+  set(CMAKE_CXX_FLAGS "/Zc:wchar_t- /EHsc /GR /W4 /MP /FAu ${CMAKE_CXX_FLAGS}")
+
+  set(LIB_INSTALL_DIR "bin")
+endif ()
+
+
+enable_testing()
+
+add_subdirectory(src)
+add_subdirectory(tst)
+
+install(FILES NindConfig.cmake DESTINATION share/apps/nind/cmake/Modules)
+
+########### packaging ###############
+INCLUDE(InstallRequiredSystemLibraries)
+
+set(CPACK_MONOLITHIC_INSTALL 1)
+set(CPACK_PACKAGE_NAME "nind")
+set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Nind Inverted file index")
+set(CPACK_PACKAGE_VENDOR "Latejcon")
+set(CPACK_PACKAGE_CONTACT "Jean-Yves Sage <jean-yves.sage@orange.fr>")
+set(CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_CURRENT_SOURCE_DIR}/README.md")
+set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENCE.md")
+set(CPACK_PACKAGE_VERSION_MAJOR "0")
+set(CPACK_PACKAGE_VERSION_MINOR "1")
+set(CPACK_PACKAGE_VERSION_PATCH "0")
+SET(CPACK_PACKAGE_VERSION "${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.${CPACK_PACKAGE_VERSION_PATCH}")
+set(CPACK_PACKAGE_INSTALL_DIRECTORY "nind-${AMOSE_VERSION_MAJOR}.${AMOSE_VERSION_MINOR}")
+set(CPACK_STRIP_FILES "")
+set(CPACK_SOURCE_STRIP_FILES "")
+set(CPACK_DEBIAN_PACKAGE_SHLIBDEPS ON)
+set(CPACK_GENERATOR ${SPECIFIC_SYSTEM_PREFERED_CPACK_GENERATOR})
+
+
+set(CPACK_PACKAGE_FILE_NAME "${CPACK_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}")
+
+# set of commands to define component based packaging
+# notify cpack of component all names
+set(CMAKE_INSTALL_DEFAULT_COMPONENT_NAME "runtime")
+SET(CPACK_COMPONENTS_ALL lib devel runtime)
+set(CPACK_RPM_COMPONENT_INSTALL ON)
+set(CPACK_DEB_COMPONENT_INSTALL ON)
+
+INCLUDE(CPack)

nind-2.0.3/Dockerfile-debian11

@@ -0,0 +1,22 @@
+FROM debian:11
+
+ARG TRAVIS_JOB_NUMBER
+
+# Setup
+RUN apt-get update -y -qq
+RUN apt-get install -y apt-utils build-essential file wget bzip2 git gcc g++ cmake cmake-data ninja-build qtbase5-dev-tools qtdeclarative5-dev -qq
+
+
+RUN mkdir -p /src/
+RUN git clone https://github.com/aymara/nind /src/nind
+
+RUN mkdir -p /src/nind/build
+
+# Build
+WORKDIR /src/nind/build
+RUN cmake -G Ninja -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_BUILD_TYPE=Release ..
+RUN ninja package
+RUN install -D /src/nind/build/nind-0.1.0.deb /usr/share/apps/nind/packages/nind-0.1.0-debian11.deb
+
+# install github-release to be able to deploy packages
+RUN /usr/bin/wget https://github.com/aktau/github-release/releases/download/v0.7.2/linux-amd64-github-release.tar.bz2 && /bin/tar xjf linux-amd64-github-release.tar.bz2 && /bin/cp bin/linux/amd64/github-release /usr/bin

nind-2.0.3/Dockerfile-debian9.4

@@ -0,0 +1,20 @@
+FROM debian:9.4
+
+ARG TRAVIS_JOB_NUMBER
+
+# Setup
+RUN apt-get update -y -qq
+RUN apt-get install -y apt-utils wget bzip2 git gcc g++ cmake cmake-data ninja-build qt5-default qtbase5-dev-tools qtdeclarative5-dev -qq
+RUN mkdir -p /src/
+RUN git clone https://github.com/aymara/nind /src/nind
+
+RUN mkdir -p /src/nind/build
+
+# Build
+WORKDIR /src/nind/build
+RUN cmake -G Ninja -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_BUILD_TYPE=Release ..
+RUN ninja package
+RUN install -D /src/nind/build/nind-0.1.0-Linux.deb /usr/share/apps/nind/packages/nind-0.1.0-debian9.4.deb
+
+# install github-release to be able to deploy packages
+RUN /usr/bin/wget https://github.com/aktau/github-release/releases/download/v0.7.2/linux-amd64-github-release.tar.bz2 && /bin/tar xjf linux-amd64-github-release.tar.bz2 && /bin/cp bin/linux/amd64/github-release /usr/bin

nind-2.0.3/Dockerfile-ubuntu16.04

@@ -0,0 +1,20 @@
+FROM ubuntu:16.04
+
+ARG TRAVIS_JOB_NUMBER
+
+# Setup
+RUN apt-get update -y -qq
+RUN apt-get install -y apt-utils wget bzip2 git gcc g++ cmake cmake-data ninja-build qt5-default qtbase5-dev-tools qtdeclarative5-dev -qq
+RUN mkdir -p /src/
+RUN git clone https://github.com/aymara/nind /src/nind
+
+RUN mkdir -p /src/nind/build
+
+# Build
+WORKDIR /src/nind/build
+RUN cmake -G Ninja -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_BUILD_TYPE=Release ..
+RUN ninja package
+RUN install -D /src/nind/build/nind-0.1.0-Linux.deb /usr/share/apps/nind/packages/nind-0.1.0-ubuntu16.04.deb
+
+# install github-release to be able to deploy packages
+RUN /usr/bin/wget https://github.com/aktau/github-release/releases/download/v0.7.2/linux-amd64-github-release.tar.bz2 && /bin/tar xjf linux-amd64-github-release.tar.bz2 && /bin/cp bin/linux/amd64/github-release /usr/bin