lapcpp 1.0.0__cp313-cp313-win_arm64.whl

lapcpp/__init__.py

@@ -0,0 +1,21 @@
+"""Native C++ linear assignment solvers with implicit rejection and batch solving."""
+
+
+# start delvewheel patch
+def _delvewheel_patch_1_13_2():
+    import os
+    if os.path.isdir(libs_dir := os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir, 'lapcpp.libs'))):
+        os.add_dll_directory(libs_dir)
+
+
+_delvewheel_patch_1_13_2()
+del _delvewheel_patch_1_13_2
+# end delvewheel patch
+
+from ._lapjv import lapjv, lapjv_batch
+
+__version__ = "1.0.0"
+__author__ = 'Ratha SIV'
+__description__ = 'Native C++ linear assignment solvers with implicit rejection and batch solving.'
+__homepage__ = 'https://github.com/rathaROG/lapcpp'
+__all__ = ["lapjv", "lapjv_batch"]

lapcpp/__init__.pyi

@@ -0,0 +1,3 @@
+from ._lapjv import lapjv as lapjv, lapjv_batch as lapjv_batch
+__version__: str
+__all__: list[str]

lapcpp/_lapjv.pyi

@@ -0,0 +1,214 @@
+# Copyright (c) 2026 Ratha SIV | MIT License
+
+"""Static signatures and documentation for the lapcpp entry points."""
+
+from typing import Any, List, Optional, Tuple, Union, overload
+from typing import Literal, Protocol
+import numpy as np
+
+_Precision = Literal["native", "float32", "float64"]
+_Output = Literal["indices", "pairs"]
+
+class _SingleSolver(Protocol):
+    @overload
+    def __call__(
+        self, cost: Any,
+        extend_cost: bool = False,
+        cost_limit: float = ...,
+        return_cost: Literal[True] = True,
+        *,
+        precision: _Precision = "native",
+        output: Literal["indices"] = "indices",
+    ) -> Tuple[float, np.ndarray, np.ndarray]: ...
+
+    @overload
+    def __call__(
+        self, cost: Any,
+        extend_cost: bool,
+        cost_limit: float,
+        return_cost: Literal[False],
+        *,
+        precision: _Precision = "native",
+        output: Literal["indices"] = "indices",
+    ) -> Tuple[np.ndarray, np.ndarray]: ...
+
+    @overload
+    def __call__(
+        self, cost: Any,
+        extend_cost: bool = False,
+        cost_limit: float = ...,
+        *,
+        return_cost: Literal[False],
+        precision: _Precision = "native",
+        output: Literal["indices"] = "indices",
+    ) -> Tuple[np.ndarray, np.ndarray]: ...
+
+    @overload
+    def __call__(
+        self, cost: Any,
+        extend_cost: bool = False,
+        cost_limit: float = ...,
+        return_cost: bool = True,
+        *,
+        precision: _Precision = "native",
+        output: Literal["indices"] = "indices",
+    ) -> Union[Tuple[float, np.ndarray, np.ndarray], Tuple[np.ndarray, np.ndarray]]: ...
+
+    @overload
+    def __call__(
+        self, cost: Any,
+        extend_cost: bool = False,
+        cost_limit: float = ...,
+        return_cost: Literal[True] = True,
+        *,
+        precision: _Precision = "native",
+        output: Literal["pairs"],
+    ) -> Tuple[float, np.ndarray]: ...
+
+    @overload
+    def __call__(
+        self, cost: Any,
+        extend_cost: bool,
+        cost_limit: float,
+        return_cost: Literal[False],
+        *,
+        precision: _Precision = "native",
+        output: Literal["pairs"],
+    ) -> np.ndarray: ...
+
+    @overload
+    def __call__(
+        self, cost: Any,
+        extend_cost: bool = False,
+        cost_limit: float = ...,
+        *,
+        return_cost: Literal[False],
+        precision: _Precision = "native",
+        output: Literal["pairs"],
+    ) -> np.ndarray: ...
+
+    @overload
+    def __call__(
+        self, cost: Any,
+        extend_cost: bool = False,
+        cost_limit: float = ...,
+        return_cost: bool = True,
+        *,
+        precision: _Precision = "native",
+        output: Literal["pairs"],
+    ) -> Union[Tuple[float, np.ndarray], np.ndarray]: ...
+
+    @overload
+    def __call__(
+        self, cost: Any, extend_cost: bool = False,
+        cost_limit: float = ..., return_cost: bool = True,
+        *, precision: _Precision = "native", output: _Output = "indices",
+    ) -> Union[Tuple[float, np.ndarray, np.ndarray], Tuple[np.ndarray, np.ndarray], Tuple[float, np.ndarray], np.ndarray]: ...
+
+class _BatchSolver(Protocol):
+    @overload
+    def __call__(
+        self, costs: Any,
+        extend_cost: bool = False,
+        cost_limit: float = ...,
+        return_cost: Literal[True] = True,
+        n_threads: Optional[int] = 0,
+        *,
+        precision: _Precision = "native",
+        output: Literal["indices"] = "indices",
+    ) -> Tuple[np.ndarray, List[np.ndarray], List[np.ndarray]]: ...
+
+    @overload
+    def __call__(
+        self, costs: Any,
+        extend_cost: bool,
+        cost_limit: float,
+        return_cost: Literal[False],
+        n_threads: Optional[int] = 0,
+        *,
+        precision: _Precision = "native",
+        output: Literal["indices"] = "indices",
+    ) -> Tuple[List[np.ndarray], List[np.ndarray]]: ...
+
+    @overload
+    def __call__(
+        self, costs: Any,
+        extend_cost: bool = False,
+        cost_limit: float = ...,
+        *,
+        return_cost: Literal[False],
+        n_threads: Optional[int] = 0,
+        precision: _Precision = "native",
+        output: Literal["indices"] = "indices",
+    ) -> Tuple[List[np.ndarray], List[np.ndarray]]: ...
+
+    @overload
+    def __call__(
+        self, costs: Any,
+        extend_cost: bool = False,
+        cost_limit: float = ...,
+        return_cost: bool = True,
+        n_threads: Optional[int] = 0,
+        *,
+        precision: _Precision = "native",
+        output: Literal["indices"] = "indices",
+    ) -> Union[Tuple[np.ndarray, List[np.ndarray], List[np.ndarray]], Tuple[List[np.ndarray], List[np.ndarray]]]: ...
+
+    @overload
+    def __call__(
+        self, costs: Any,
+        extend_cost: bool = False,
+        cost_limit: float = ...,
+        return_cost: Literal[True] = True,
+        n_threads: Optional[int] = 0,
+        *,
+        precision: _Precision = "native",
+        output: Literal["pairs"],
+    ) -> Tuple[np.ndarray, List[np.ndarray]]: ...
+
+    @overload
+    def __call__(
+        self, costs: Any,
+        extend_cost: bool,
+        cost_limit: float,
+        return_cost: Literal[False],
+        n_threads: Optional[int] = 0,
+        *,
+        precision: _Precision = "native",
+        output: Literal["pairs"],
+    ) -> List[np.ndarray]: ...
+
+    @overload
+    def __call__(
+        self, costs: Any,
+        extend_cost: bool = False,
+        cost_limit: float = ...,
+        *,
+        return_cost: Literal[False],
+        n_threads: Optional[int] = 0,
+        precision: _Precision = "native",
+        output: Literal["pairs"],
+    ) -> List[np.ndarray]: ...
+
+    @overload
+    def __call__(
+        self, costs: Any,
+        extend_cost: bool = False,
+        cost_limit: float = ...,
+        return_cost: bool = True,
+        n_threads: Optional[int] = 0,
+        *,
+        precision: _Precision = "native",
+        output: Literal["pairs"],
+    ) -> Union[Tuple[np.ndarray, List[np.ndarray]], List[np.ndarray]]: ...
+
+    @overload
+    def __call__(
+        self, costs: Any, extend_cost: bool = False,
+        cost_limit: float = ..., return_cost: bool = True,
+        n_threads: Optional[int] = 0,
+        *, precision: _Precision = "native", output: _Output = "indices",
+    ) -> Union[Tuple[np.ndarray, List[np.ndarray], List[np.ndarray]], Tuple[List[np.ndarray], List[np.ndarray]], Tuple[np.ndarray, List[np.ndarray]], List[np.ndarray]]: ...
+
+lapjv: _SingleSolver
+lapjv_batch: _BatchSolver

lapcpp/py.typed

@@ -0,0 +1,3 @@
+# PEP 561 marker: tells type checkers that lap provides inline type annotations.
+# Keep this file in source distributions and wheels so IDEs can use those types.
+# This file is package metadata; Python does not execute it.

lapcpp-1.0.0.dist-info/DELVEWHEEL

@@ -0,0 +1,2 @@
+Version: 1.13.2
+Arguments: ['C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-fzg4ohkk\\cp313-win_arm64\\build\\venv\\Scripts\\delvewheel', 'repair', '--add-path', 'C:\\Program Files\\Microsoft Visual Studio\\18\\Enterprise\\VC\\Redist\\MSVC\\14.51.36231\\arm64\\Microsoft.VC145.CRT', '-w', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-fzg4ohkk\\cp313-win_arm64\\repaired_wheel', '-v', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-fzg4ohkk\\cp313-win_arm64\\built_wheel\\lapcpp-1.0.0-cp313-cp313-win_arm64.whl']

lapcpp-1.0.0.dist-info/METADATA

@@ -0,0 +1,206 @@
+Metadata-Version: 2.4
+Name: lapcpp
+Version: 1.0.0
+Summary: Native C++ linear assignment solvers with implicit rejection and batch solving
+Home-page: https://github.com/rathaROG/lapcpp
+Author: Ratha SIV
+Maintainer: rathaROG
+License: MIT
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Topic :: Education
+Classifier: Topic :: Education :: Testing
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Unix
+Classifier: Operating System :: MacOS
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+License-File: tests/LICENSE
+License-File: src/_lapjv/LICENSE
+Requires-Dist: numpy>=1.21.6
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Requires-Dist: scipy>=1.9; extra == "test"
+Requires-Dist: pytest-timeout; extra == "test"
+Provides-Extra: benchmark
+Requires-Dist: scipy>=1.9; extra == "benchmark"
+Requires-Dist: lapx==0.11.1; extra == "benchmark"
+Provides-Extra: dev
+Requires-Dist: build; extra == "dev"
+Requires-Dist: setuptools>=77; extra == "dev"
+Requires-Dist: wheel; extra == "dev"
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: scipy>=1.9; extra == "dev"
+Requires-Dist: pytest-timeout; extra == "dev"
+Requires-Dist: pyright; extra == "dev"
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: maintainer
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# lapcpp
+
+**lapcpp** solves dense linear assignment problems with a native
+C++ implementation and a NumPy API. Python **3.9 or newer** is required.
+It exposes two solvers: `lapjv` and `lapjv_batch`.
+
+lapcpp 1.0.0 derives from the `lapjvh` solver in LAPX 0.11.1.
+Future solver development is led by lapcpp for C++ and laprust for Rust;
+LAPX will incorporate their fixes and improvements.
+
+It solves rectangular problems directly and handles unmatched rows and columns
+implicitly when a finite `cost_limit` is supplied, without allocating an expanded
+square cost matrix.
+The square path uses Jonker–Volgenant initialization, reduction, and shortest
+augmenting paths. This package is independent of LAPX and imports as `lapcpp`.
+
+## Installation
+
+Once available on PyPI:
+
+```sh
+python -m pip install lapcpp
+```
+
+A source build requires a C++17 compiler and, for `laprust`, Rust/Cargo 1.83+
+with a compatible target. Build dependencies (NumPy, Cython, setuptools) are
+installed automatically by pip. NumPy is the only Python runtime dependency.
+An installed wheel needs no compiler or Rust toolchain.
+
+## Quick start
+
+```python
+import numpy as np
+import lapcpp
+
+cost = np.array([[3., 1.], [1., 4.]])
+total, rows, cols = lapcpp.lapjv(cost)
+# total = 2.0; rows = [0, 1]; cols = [1, 0]
+
+costs = np.stack([cost, cost])  # (batch, rows, columns)
+totals, rows, cols = lapcpp.lapjv_batch(costs, n_threads=2)
+# totals = [2., 2.]; rows and cols are lists of arrays, one per problem
+
+rectangular = np.array([[.1, .8, .9], [.9, .7, .8]], dtype=np.float32)
+total, rows, cols = lapcpp.lapjv(rectangular, cost_limit=.5)
+# Only (0, 0) is selected; total is about .1, excluding rejection penalties.
+```
+
+## API
+
+```python
+lapjv(cost, extend_cost=False, cost_limit=np.inf, return_cost=True,
+      *, precision="native", output="indices")
+lapjv_batch(costs, extend_cost=False, cost_limit=np.inf, return_cost=True,
+            n_threads=0, *, precision="native", output="indices")
+```
+
+| Option | Behavior |
+| --- | --- |
+| `cost` / `costs` | Real numeric arrays with shape `(N, M)` / `(B, N, M)`. |
+| `extend_cost=True` | Allows rectangular inputs when the limit is infinite; no square padding is used. |
+| `cost_limit` | A finite value permits unmatched endpoints at a penalty of `cost_limit / 2` each. Finite limits also permit rectangles and apply to square inputs. |
+| `return_cost` | Defaults to `True`; totals sum selected original costs in float64 and exclude rejection penalties. `False` omits totals and skips the sum. |
+| `precision` | `"native"` preserves float32/float64; other real numeric inputs use float64. Explicit `"float32"` / `"float64"` select working costs. |
+| `output` | `"indices"` returns aligned row/column arrays; `"pairs"` returns `(K, 2)` arrays. |
+| `n_threads` | Batch only. `0` / `None` selects automatically; negative values use one worker; positive values are capped by batch size. |
+
+Rows are sorted and all returned indices are int64. They identify the selected
+pairs; unmatched items are absent. Batch results contain lists because each
+problem may select a different number of pairs. Equal-cost optima may return
+different assignments across solvers or precisions.
+
+With a finite limit `L`, the optimized objective is
+`sum(selected costs) + (N + M - 2*K) * L/2`.
+The reported `total` contains only the first term. Joint rejection is different
+from solving a full assignment and then filtering high-cost pairs.
+See [API details](docs/api.md) for numerical and memory behavior.
+
+## Development and checks
+
+```sh
+python -m pip install -e ".[dev]"
+cd tests
+python -m pytest -q -m "not cross_package"
+cd ..
+python -m pytest -q .github/tests -m "not editable"
+python -m build
+```
+
+The test suite covers SciPy and exhaustive-reference comparisons, rectangular
+and finite-limit cases, float32/float64, precision conversion, forbidden edges,
+empty inputs, invalid arguments, repeated workspaces, batch thread counts,
+concurrent calls, package independence, and type annotations.
+Historical LAPX regressions, cross-package concurrency, and isolated editable
+installs are also covered. See the [solver test inventory](tests/README.md),
+[build and packaging checks](.github/tests/README.md), and
+[CONTRIBUTING.md](CONTRIBUTING.md) for commands and coverage.
+
+## Benchmarks
+
+All three benchmark scripts compare **SciPy (baseline), lapcpp, laprust,
+LAPX lapjvxa and LAPX lapjvsa**. The LAPX candidates represent the JVX and JVS
+families using pair outputs, including their batch APIs. Once lapcpp and laprust
+are available on PyPI, install the dependencies below. Clone or
+download this repository for the scripts and run them from the repository root.
+
+```sh
+python -m pip install --upgrade lapcpp laprust "lapx==0.11.1" scipy
+python benchmarks/benchmark_single.py --quick --repeats 3
+python benchmarks/benchmark_batch.py --quick --threads 4 --repeats 3
+python benchmarks/benchmark_tracking.py --quick --repeats 3
+```
+
+Use `--json benchmark-results/run.json` to save measurements and environment
+details. Each solver is warmed right before its own sample, and calls repeat
+until a sample lasts at least 10 ms; `--reference-timing` restores the pinned
+LAPX timing. See [benchmark methodology](benchmarks/README.md) for full workloads,
+reference LAPX settings, dedicated solver functions, tracking post-filtering, and
+timing boundaries. Tracking never passes its threshold as solver `cost_limit`.
+
+## Paper
+
+The solver, its implicit rejection, and its performance against SciPy and other
+Jonker–Volgenant implementations are described in *Native Rectangular Linear
+Assignment with Implicit Rejection: A Jonker–Volgenant Solver without Square
+Expansion*, where lapcpp is labeled JVCPP. Read the
+[PDF](https://github.com/rathaROG/lap-paper/blob/main/output/pdf/native_rectangular_assignment.pdf);
+its scripts, raw results, and reproduction steps are in the
+[lap-paper](https://github.com/rathaROG/lap-paper) repository.
+
+## Automation and license
+
+GitHub workflows test supported Python versions on Windows, Linux and macOS,
+build and test source archives and wheels, and run the three benchmark modes.
+Wheel builds are also available manually. A version tag triggers the release
+workflow; PyPI publishing uses the repository's `pypi` environment and requires
+its Trusted Publisher configuration. No releases are published by local builds.
+
+MIT licensed. See [LICENSE](LICENSE), [NOTICE](NOTICE), and
+[native-source license](src/_lapjv/LICENSE) for attribution.

lapcpp-1.0.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+lapcpp/py.typed,sha256=oD5aTIMVm1T_JgT9BBWE-NnjwwrBB8obapedLpgBAIw,224
+lapcpp/_lapjv.cp313-win_arm64.pyd,sha256=yNU5GQ7Bzg7VTUV-wlxgDrPaAHCtsfN-BASGpnaKxao,173056
+lapcpp/_lapjv.pyi,sha256=6m3PseIodDLZJOefmPisHILaeHOSGAYTxOR29Qd2tY8,6667
+lapcpp/__init__.py,sha256=bMRp9bHWQyDEBn5thkvxjoEMDsMYik77tpfzM10nzbg,693
+lapcpp/__init__.pyi,sha256=lBZQwPZlnjCne2rE5a85Y9diKHVMqyowgBmuA2C9Jo4,102
+lapcpp-1.0.0.dist-info/DELVEWHEEL,sha256=dEbW2xsPvNhZ5WZUBv-Ld_hD3977--UgqQ_WrZb1bx8,540
+lapcpp-1.0.0.dist-info/METADATA,sha256=4BD09VJzOZb2EGPZxad0-UesMHOkkhaOhRExOVRcZg0,9021
+lapcpp-1.0.0.dist-info/RECORD,,
+lapcpp-1.0.0.dist-info/top_level.txt,sha256=hRzd-3vte45FX1s-c2Ff90stQVMvmtz-8VaealriXfs,7
+lapcpp-1.0.0.dist-info/WHEEL,sha256=ayu21Mpadbv-ezysr7KMvwt_cMNEKGc6DXRKBGsIOVc,101
+lapcpp-1.0.0.dist-info/licenses/LICENSE,sha256=CwiIqXxH7u-IMqGpwv76ZusNV6NTJ6lUxtFY7OA3tfs,1086
+lapcpp-1.0.0.dist-info/licenses/NOTICE,sha256=iS5idwxB3Us51wc7F7uvRCwuThO02Et_p35YW9TOgVc,671
+lapcpp-1.0.0.dist-info/licenses/src/_lapjv/LICENSE,sha256=jX3ViOgZaNCvcXnIYO25Gjz3IuliYGm0SoC1eaHG3jw,1136
+lapcpp-1.0.0.dist-info/licenses/tests/LICENSE,sha256=ywsyoyzHjv5Up3ccXuz6Z8fyRchCjVhSZkYbaJu2nIs,1361
+lapcpp.libs/msvcp140-167ceac85c2d726c4cd9e39b8881fafd.dll,sha256=FnzqyFwtcmxM2eObiIH6_cbeFSDA5nxPaycSNfnSpsU,1588064

lapcpp-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: false
+Tag: cp313-cp313-win_arm64
+

lapcpp-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 rathaROG
+
+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.

lapcpp-1.0.0.dist-info/licenses/NOTICE

@@ -0,0 +1,10 @@
+lapcpp 1.0.0 is derived from the lapjvh solver family of LAPX 0.11.1
+(rathaROG/lapx, v0.11.1).
+
+The square Jonker-Volgenant implementation derives from source{d}/lapjv
+and carries the copyright of Vadim Markovtsev (2016). Native rectangular
+assignment, implicit rejection handling, adapters and batch execution derive
+from Ratha SIV's LAPX work (2026). See src/_lapjv/LICENSE for the full MIT text.
+The top-level LICENSE covers this package. Neither package requires LAPX.
+
+Historical regression matrices and fixture generators are adapted from LAPX/gatagat-lap tests under BSD-2-Clause. See tests/LICENSE. The epsilon dataset was contributed by Michael Lewis.

lapcpp-1.0.0.dist-info/licenses/src/_lapjv/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2016 Vadim Markovtsev (source{d})
+Copyright (c) 2026 Ratha SIV
+
+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.

lapcpp-1.0.0.dist-info/licenses/tests/LICENSE

@@ -0,0 +1,25 @@
+BSD 2-Clause License
+
+Copyright (c) 2012-2025, Tomas Kazmar
+Copyright (c) 2026, Ratha SIV
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

lapcpp-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+lapcpp