fastrectpack 0.1.0__cp313-cp313-win_amd64.whl

fastrectpack/__init__.py

@@ -0,0 +1,28 @@
+"""fastrectpack: a drop-in accelerator for rectpack (https://github.com/secnot/rectpack).
+
+Use it exactly like rectpack:
+
+    from fastrectpack import newPacker
+    packer = newPacker()
+    ...
+
+Everything rectpack exports is re-exported unchanged, except the MaxRects algorithms, which run in C++ when
+all sizes are plain Python ints. Any other input is handled by the original rectpack code.
+"""
+from rectpack import *  # noqa: F401,F403  (re-export the full original API)
+from rectpack import SORT_AREA, PackingBin, PackingMode
+from rectpack import newPacker as _newPacker
+
+from ._maxrects import NATIVE_AVAILABLE as NATIVE_AVAILABLE
+from ._maxrects import MaxRectsBaf as MaxRectsBaf
+from ._maxrects import MaxRectsBl as MaxRectsBl
+from ._maxrects import MaxRectsBlsf as MaxRectsBlsf
+from ._maxrects import MaxRectsBssf as MaxRectsBssf
+
+__version__ = "0.1.0"
+
+
+def newPacker(mode=PackingMode.Offline, bin_algo=PackingBin.BBF, pack_algo=MaxRectsBssf,
+              sort_algo=SORT_AREA, rotation=True):
+    """Same signature and behaviour as rectpack.newPacker; the default algorithm is the accelerated one."""
+    return _newPacker(mode=mode, bin_algo=bin_algo, pack_algo=pack_algo, sort_algo=sort_algo, rotation=rotation)

fastrectpack/_maxrects.py

@@ -0,0 +1,105 @@
+"""Native-backed drop-in replacements for rectpack's MaxRects* classes.
+
+Each class subclasses the original (so isinstance checks and every method we do not override still work),
+runs the algorithm in C++ while all dimensions are plain Python ints, and falls back to the original Python
+code, permanently for that object, the first time it sees anything else (floats, Decimals, numpy ints, bools,
+zero or negative sizes, huge ints). The fallback is the original code, so results and errors are the same.
+"""
+from rectpack import maxrects as _orig
+from rectpack.geometry import Rectangle
+from rectpack.pack_algo import PackingAlgorithm
+
+try:
+    from . import _native
+except ImportError:  # extension not built: everything below degrades to the original behaviour
+    _native = None
+
+NATIVE_AVAILABLE = _native is not None
+
+
+class _NativeMaxRects:
+    _variant = 0  # overridden by each concrete class
+
+    def reset(self):
+        PackingAlgorithm.reset(self)  # self.rectangles = []
+        self.__dict__.pop("_max_rects", None)
+        core = None
+        if _native is not None:
+            try:
+                core = _native.Core(self.width, self.height, bool(self.rot), self._variant)
+            except _native.Deopt:
+                core = None
+        self._native = core
+        if core is None:
+            self._max_rects = [Rectangle(0, 0, self.width, self.height)]
+
+    def _deopt(self):
+        """Hand the current state over to the original Python implementation for good."""
+        core = self._native
+        self._max_rects = [Rectangle(*t) for t in core.free_rects()]
+        self._native = None
+
+    def __getattr__(self, name):
+        # Only reached when normal lookup fails: lets code that peeks at _max_rects keep working.
+        if name == "_max_rects":
+            core = self.__dict__.get("_native")
+            if core is not None:
+                return [Rectangle(*t) for t in core.free_rects()]
+        raise AttributeError(name)
+
+    def fitness(self, width, height):
+        core = self._native
+        if core is not None:
+            try:
+                return core.fitness(width, height)
+            except _native.Deopt:
+                self._deopt()
+        return super().fitness(width, height)
+
+    def add_rect(self, width, height, rid=None):
+        core = self._native
+        if core is not None:
+            try:
+                placed = core.add_rect(width, height)
+            except _native.Deopt:
+                self._deopt()
+            else:
+                if placed is None:
+                    return None
+                rect = Rectangle(*placed)
+                rect.rid = rid
+                self.rectangles.append(rect)
+                return rect
+        return super().add_rect(width, height, rid)
+
+    # pickle / copy.deepcopy: the C++ object cannot be pickled, so serialise as plain Python state
+    def __getstate__(self):
+        state = dict(self.__dict__)
+        core = state.pop("_native", None)
+        if core is not None:
+            state["_max_rects"] = [Rectangle(*t) for t in core.free_rects()]
+        state["_native"] = None
+        return state
+
+
+_BL = _native.BL if _native else 0
+_BSSF = _native.BSSF if _native else 1
+_BAF = _native.BAF if _native else 2
+_BLSF = _native.BLSF if _native else 3
+
+
+class MaxRectsBl(_NativeMaxRects, _orig.MaxRectsBl):
+    _variant = _BL
+
+
+class MaxRectsBssf(_NativeMaxRects, _orig.MaxRectsBssf):
+    """Best Short Side Fit (the rectpack default)."""
+    _variant = _BSSF
+
+
+class MaxRectsBaf(_NativeMaxRects, _orig.MaxRectsBaf):
+    _variant = _BAF
+
+
+class MaxRectsBlsf(_NativeMaxRects, _orig.MaxRectsBlsf):
+    _variant = _BLSF

fastrectpack/_native.cpp

@@ -0,0 +1,244 @@
+// Native core for the MaxRects family of rectpack (https://github.com/secnot/rectpack, Apache-2.0).
+//
+// This is a port of rectpack.maxrects (MaxRectsBl / Bssf / Baf / Blsf) for plain Python int dimensions.
+// It reproduces the original's behaviour exactly, including its quirks:
+//   * candidates are scanned in free-rectangle order, normal orientation first, then rotated, and the FIRST
+//     minimal candidate wins (Python's min() semantics);
+//   * MaxRectsBl compares only (y + height); its docstring promises an x tie-break but the code does not do it;
+//   * _remove_duplicates removes every free rectangle whose *value* equals that of a contained rectangle, so two
+//     identical free rectangles are both dropped.
+//
+// Anything outside the exact-int fast path raises Deopt and the Python wrapper falls back to the original code.
+
+#include <pybind11/pybind11.h>
+
+#include <algorithm>
+#include <cstdint>
+#include <memory>
+#include <stdexcept>
+#include <tuple>
+#include <vector>
+
+namespace py = pybind11;
+using i64 = std::int64_t;
+
+namespace {
+
+// Keep every intermediate (sums, and products used by Baf) far from int64 overflow.
+constexpr i64 kLimit = i64(1) << 30;
+
+struct Deopt : std::runtime_error {
+    Deopt() : std::runtime_error("input outside the native fast path") {}
+};
+
+struct Rect {
+    i64 x, y, w, h;
+    i64 top() const { return y + h; }
+    i64 right() const { return x + w; }
+    bool operator==(const Rect& o) const { return x == o.x && y == o.y && w == o.w && h == o.h; }
+    bool operator<(const Rect& o) const { return std::tie(x, y, w, h) < std::tie(o.x, o.y, o.w, o.h); }
+};
+
+enum Variant : int { kBl = 0, kBssf = 1, kBaf = 2, kBlsf = 3 };
+
+// Exact Python int only (not bool, not numpy ints, not floats). Returns false when not representable.
+bool as_i64(PyObject* o, i64& out) {
+    if (!PyLong_CheckExact(o)) return false;
+    int overflow = 0;
+    long long v = PyLong_AsLongLongAndOverflow(o, &overflow);
+    if (overflow != 0) return false;
+    if (v == -1 && PyErr_Occurred()) {
+        PyErr_Clear();
+        return false;
+    }
+    out = static_cast<i64>(v);
+    return true;
+}
+
+// rectpack Rectangle.contains(): `a` contains `b`
+inline bool contains(const Rect& a, const Rect& b) {
+    return b.y >= a.y && b.x >= a.x && b.top() <= a.top() && b.right() <= a.right();
+}
+
+class Core {
+public:
+    Core(i64 width, i64 height, bool rot, int variant) : rot_(rot), variant_(static_cast<Variant>(variant)) {
+        free_.push_back(Rect{0, 0, width, height});
+    }
+
+    // Returns fitness (>= 0), or -1 when the rectangle cannot be placed.
+    i64 fitness(i64 w, i64 h) const {
+        Rect placed;
+        size_t idx;
+        if (!select(w, h, placed, idx)) return -1;
+        return rect_fitness(free_[idx], placed.w, placed.h);
+    }
+
+    bool add_rect(i64 w, i64 h, Rect& placed) {
+        size_t idx;
+        if (!select(w, h, placed, idx)) return false;
+        split(placed);
+        return true;
+    }
+
+    const std::vector<Rect>& free_rects() const { return free_; }
+
+private:
+    // Mirrors MaxRects*._rect_fitness for the variant. Caller guarantees (cw, ch) fits inside m.
+    i64 rect_fitness(const Rect& m, i64 cw, i64 ch) const {
+        switch (variant_) {
+            case kBssf:
+                return std::min(m.w - cw, m.h - ch);
+            case kBaf:
+                return m.w * m.h - cw * ch;
+            case kBlsf:
+                return std::max(m.w - cw, m.h - ch);
+            default:
+                return 0;  // MaxRectsBl uses the base-class fitness
+        }
+    }
+
+    // Mirrors MaxRects*._select_position: first minimal candidate, normal orientation before rotated.
+    bool select(i64 w, i64 h, Rect& placed, size_t& idx) const {
+        bool have = false;
+        i64 best_key = 0;
+        for (size_t i = 0; i < free_.size(); ++i) {
+            const Rect& m = free_[i];
+            if (w <= m.w && h <= m.h) {
+                i64 key = (variant_ == kBl) ? m.y + h : rect_fitness(m, w, h);
+                if (!have || key < best_key) {
+                    have = true;
+                    best_key = key;
+                    placed = Rect{m.x, m.y, w, h};
+                    idx = i;
+                }
+            }
+        }
+        if (rot_) {
+            for (size_t i = 0; i < free_.size(); ++i) {
+                const Rect& m = free_[i];
+                if (h <= m.w && w <= m.h) {
+                    i64 key = (variant_ == kBl) ? m.y + w : rect_fitness(m, h, w);
+                    if (!have || key < best_key) {
+                        have = true;
+                        best_key = key;
+                        placed = Rect{m.x, m.y, h, w};
+                        idx = i;
+                    }
+                }
+            }
+        }
+        return have;
+    }
+
+    // Mirrors MaxRects._split followed by MaxRects._remove_duplicates.
+    void split(const Rect& r) {
+        std::vector<Rect> next;
+        std::vector<char> is_new;
+        next.reserve(free_.size() + 8);
+        is_new.reserve(free_.size() + 8);
+        for (const Rect& m : free_) {
+            bool intersects = !(m.y >= r.top() || m.top() <= r.y || m.x >= r.right() || m.right() <= r.x);
+            if (!intersects) {
+                next.push_back(m);
+                is_new.push_back(0);
+                continue;
+            }
+            // _generate_splits, same order: left, right, top, bottom
+            if (r.x > m.x) {
+                next.push_back(Rect{m.x, m.y, r.x - m.x, m.h});
+                is_new.push_back(1);
+            }
+            if (r.right() < m.right()) {
+                next.push_back(Rect{r.right(), m.y, m.right() - r.right(), m.h});
+                is_new.push_back(1);
+            }
+            if (r.top() < m.top()) {
+                next.push_back(Rect{m.x, r.top(), m.w, m.top() - r.top()});
+                is_new.push_back(1);
+            }
+            if (r.y > m.y) {
+                next.push_back(Rect{m.x, m.y, m.w, r.y - m.y});
+                is_new.push_back(1);
+            }
+        }
+
+        // _remove_duplicates. The original drops every rectangle whose VALUE equals the value of some rectangle
+        // that is contained by another one. Because the list it leaves behind never contains a containing pair,
+        // only pairs that involve a newly created piece can add to that set, so checking those is equivalent
+        // to the original's all-pairs scan (verified against the original by the parity tests).
+        std::vector<Rect> flagged;
+        const size_t n = next.size();
+        for (size_t i = 0; i < n; ++i) {
+            if (!is_new[i]) continue;
+            for (size_t j = 0; j < n; ++j) {
+                if (j == i) continue;
+                if (contains(next[i], next[j])) flagged.push_back(next[j]);
+                if (contains(next[j], next[i])) flagged.push_back(next[i]);
+            }
+        }
+        if (flagged.empty()) {
+            free_.swap(next);
+            return;
+        }
+        std::sort(flagged.begin(), flagged.end());
+        flagged.erase(std::unique(flagged.begin(), flagged.end()), flagged.end());
+        free_.clear();
+        for (const Rect& m : next) {
+            if (!std::binary_search(flagged.begin(), flagged.end(), m)) free_.push_back(m);
+        }
+    }
+
+    bool rot_;
+    Variant variant_;
+    std::vector<Rect> free_;
+};
+
+inline void need_dim(PyObject* o, i64& out) {
+    if (!as_i64(o, out) || out < 1 || out > kLimit) throw Deopt();
+}
+
+std::unique_ptr<Core> make_core(py::handle width, py::handle height, bool rot, int variant) {
+    i64 w, h;
+    need_dim(width.ptr(), w);
+    need_dim(height.ptr(), h);
+    return std::make_unique<Core>(w, h, rot, variant);
+}
+
+}  // namespace
+
+PYBIND11_MODULE(_native, m) {
+    m.doc() = "Native core for the MaxRects family of rectpack (exact-int fast path)";
+    py::register_exception<Deopt>(m, "Deopt");
+
+    py::class_<Core>(m, "Core")
+        .def(py::init(&make_core), py::arg("width"), py::arg("height"), py::arg("rot"), py::arg("variant"))
+        .def("fitness",
+             [](const Core& c, py::handle w, py::handle h) -> py::object {
+                 i64 iw, ih;
+                 need_dim(w.ptr(), iw);
+                 need_dim(h.ptr(), ih);
+                 i64 f = c.fitness(iw, ih);
+                 if (f < 0) return py::none();
+                 return py::int_(f);
+             })
+        .def("add_rect",
+             [](Core& c, py::handle w, py::handle h) -> py::object {
+                 i64 iw, ih;
+                 need_dim(w.ptr(), iw);
+                 need_dim(h.ptr(), ih);
+                 Rect placed;
+                 if (!c.add_rect(iw, ih, placed)) return py::none();
+                 return py::make_tuple(placed.x, placed.y, placed.w, placed.h);
+             })
+        .def("free_rects", [](const Core& c) {
+            py::list out;
+            for (const Rect& r : c.free_rects()) out.append(py::make_tuple(r.x, r.y, r.w, r.h));
+            return out;
+        });
+
+    m.attr("BL") = static_cast<int>(kBl);
+    m.attr("BSSF") = static_cast<int>(kBssf);
+    m.attr("BAF") = static_cast<int>(kBaf);
+    m.attr("BLSF") = static_cast<int>(kBlsf);
+}

fastrectpack-0.1.0.dist-info/METADATA

@@ -0,0 +1,164 @@
+Metadata-Version: 2.4
+Name: fastrectpack
+Version: 0.1.0
+Summary: Drop-in C++ accelerator for rectpack's MaxRects 2D packing algorithms, with identical output
+Keywords: rectpack,bin packing,rectangle packing,2d packing,nesting,pybind11,performance
+Author: Ramcharan
+License-Expression: Apache-2.0
+License-File: LICENSE
+License-File: NOTICE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+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: Topic :: Software Development :: Libraries :: Python Modules
+Project-URL: Homepage, https://github.com/p-ramcharan-dev/fastrectpack
+Project-URL: Source, https://github.com/p-ramcharan-dev/fastrectpack
+Project-URL: Issues, https://github.com/p-ramcharan-dev/fastrectpack/issues
+Project-URL: Benchmarks, https://github.com/p-ramcharan-dev/fastrectpack/blob/main/BENCHMARKS.md
+Project-URL: Original library, https://github.com/secnot/rectpack
+Requires-Python: >=3.9
+Requires-Dist: rectpack==0.2.2
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: hypothesis; extra == "test"
+Description-Content-Type: text/markdown
+
+# fastrectpack
+
+[![ci](https://github.com/p-ramcharan-dev/fastrectpack/actions/workflows/ci.yml/badge.svg)](https://github.com/p-ramcharan-dev/fastrectpack/actions/workflows/ci.yml)
+[![wheels](https://github.com/p-ramcharan-dev/fastrectpack/actions/workflows/wheels.yml/badge.svg)](https://github.com/p-ramcharan-dev/fastrectpack/actions/workflows/wheels.yml)
+![License: Apache-2.0](https://img.shields.io/badge/license-Apache--2.0-blue)
+![Python 3.9 to 3.13](https://img.shields.io/badge/python-3.9%20to%203.13-blue)
+
+A drop-in accelerator for [rectpack](https://github.com/secnot/rectpack), the pure-Python 2D rectangle packing library. The MaxRects packing algorithms are re-implemented in C++17 and produce **exactly the same packings** as the original, 5x to 246x faster depending on the workload.
+
+```python
+# before
+from rectpack import newPacker
+# after: nothing else changes
+from fastrectpack import newPacker
+```
+
+## Headline numbers
+
+Default `newPacker()` settings. Times are the best recorded run; full method and all 14 cases are in [BENCHMARKS.md](https://github.com/p-ramcharan-dev/fastrectpack/blob/main/BENCHMARKS.md).
+
+| Workload | Rectangles | Original rectpack | Pure-Python fixes only | fastrectpack (C++) | Speedup |
+|---|---|---|---|---|---|
+| random sizes | 1,000 | 3.525 s | 0.473 s | 0.0144 s | 246x |
+| random sizes | 5,000 | 21.123 s | 3.738 s | 0.1364 s | 155x |
+| few large, many small | 1,000 | 1.360 s | 0.243 s | 0.0102 s | 133x |
+| sprite sizes | 2,000 | 1.500 s | 0.322 s | 0.0177 s | 85x |
+| sheet cutting, 100 bins | 2,000 | 0.415 s | 0.214 s | 0.0780 s | 5x |
+
+Two things to read from this table:
+
+- **Part of the win needs no C++.** A better algorithm in plain Python gives 1.7x to 7.5x on its own (the "Pure-Python fixes only" column). The C++ port supplies the rest.
+- **The gain depends on the workload.** Jobs that spread rectangles over many bins gain about 5x, because the bin-selection loop is still Python. See "What is not faster" below.
+
+The benchmark machine is a laptop that drops into slow phases (probably thermal throttling), so absolute seconds vary by up to about 2.3x. Best-time speedup ratios agreed to roughly 10% between full runs.
+
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/p-ramcharan-dev/fastrectpack/main/docs/benchmarks-dark.png">
+    <img alt="Dumbbell chart of the speedup over the original rectpack for 14 workloads, log scale. Pure-Python fixes alone give 1.7x to 7.5x; the C++ version gives 5x to 246x, with output identical in every case. Jobs that spread rectangles over many bins gain about 5x. The same numbers are in the tables in this README and in BENCHMARKS.md." src="https://raw.githubusercontent.com/p-ramcharan-dev/fastrectpack/main/docs/benchmarks-light.png" width="760">
+  </picture>
+</p>
+
+## Install
+
+```
+pip install fastrectpack
+```
+
+Prebuilt wheels cover CPython 3.9 to 3.13 on Linux x86_64 (manylinux), Windows x86_64 and macOS arm64 (Apple silicon). Other platforms (Linux ARM, Intel Macs, Alpine/musl) and Python 3.14 are untested and build from the source distribution, which needs CMake 3.15+ and a C++17 compiler (MSVC 2019+, GCC 9+ or Clang 10+). From a checkout: `pip install .`. `rectpack==0.2.2` is installed as a dependency.
+
+## Usage
+
+Identical to rectpack:
+
+```python
+from fastrectpack import newPacker
+
+packer = newPacker()
+for width, height in [(100, 30), (40, 60), (30, 30), (70, 70), (100, 50), (30, 30)]:
+    packer.add_rect(width, height)
+packer.add_bin(300, 450)
+packer.pack()
+
+for bin_index, x, y, w, h, rid in packer.rect_list():
+    print(bin_index, x, y, w, h)
+```
+
+`fastrectpack` re-exports everything rectpack exports. `MaxRectsBl`, `MaxRectsBssf`, `MaxRectsBaf` and `MaxRectsBlsf` are replaced by accelerated subclasses of the originals; everything else is the original object.
+
+## How it works
+
+The four MaxRects classes subclass the originals and run the algorithm in a small C++17 core while every size is a plain Python `int`. Anything else falls back, for good, to the original Python code for that object.
+
+Profiling the original showed about 90% of its time in one step that compares every pair of free rectangles after each placement. The port compares only the pairs that involve newly created rectangles, which is valid because the list left by the previous step contains no rectangle that contains another. [docs/DESIGN.md](https://github.com/p-ramcharan-dev/fastrectpack/blob/main/docs/DESIGN.md) covers the design, exactly what "identical" means, and the known gaps.
+
+## What is accelerated
+
+| | Accelerated |
+|---|---|
+| MaxRects algorithms (Bl, Bssf, Baf, Blsf), with or without rotation | Yes |
+| All bin heuristics (BNF, BFF, BBF, Global), online and offline modes, all sort orders | Yes, when used with a MaxRects algorithm |
+| Sizes given as plain Python `int`, up to 2^30 | Yes |
+| Sizes given as `float`, `Decimal`, numpy integers or `bool` | No: handled by the original code, same result, original speed |
+| Skyline and Guillotine algorithms | No: unchanged original code |
+
+When an accelerated object meets an input outside the fast path, it hands its state to the original Python implementation and continues there, so results and error messages stay the same.
+
+## What is not faster
+
+- **Many-bin workloads.** With 100 open bins, most of the time goes to the Python loop that asks every bin how well a rectangle fits. That loop was left in Python, so the gain there is about 5x.
+- **Non-integer sizes.** Floats and Decimals run at the original speed.
+- **Skyline and Guillotine.** Not ported.
+
+## How correctness was checked
+
+- **Exact parity.** After every single placement, the tests compare the fitness value, the placement and the complete list of free rectangles (including its order) against the original. 474 tests, including two Hypothesis property tests (300 and 150 generated cases) and all 200 packer configurations that use a MaxRects algorithm.
+- **Edge cases.** Floats, Decimals, NaN, infinity, zero and negative sizes, booleans, strings, `None`, numpy integers, integers beyond the native range, exact fits, pieces larger than the bin. Results and exceptions match the original.
+- **Benchmark outputs.** Every benchmark run hashes the full result of all three variants; all 14 cases are identical.
+- **Sanitizers.** The suite passes under AddressSanitizer and UndefinedBehaviorSanitizer, both locally (GCC 15.2 in WSL) and on a GitHub Actions Ubuntu runner.
+- **Mutation check.** Six deliberate bugs were injected into the C++. The tests caught five; the sixth (treating edge-touching rectangles as overlapping) only adds free rectangles that the next step deletes, so the output cannot change. I reasoned that through rather than proving it formally.
+- **Platforms and Python versions.** In GitHub Actions the test suite ran inside every built wheel: Python 3.9, 3.10, 3.11, 3.12 and 3.13 on Linux x86_64, Windows x86_64 and macOS arm64. Locally it also passes on 3.13 and 3.11 on Windows.
+
+Run them yourself:
+
+```
+pip install ".[test]"
+pytest
+python bench/run_bench.py --quick     # about a minute
+python bench/run_bench.py             # full benchmark, several minutes
+```
+
+## Behaviour inherited from rectpack
+
+These were found while porting. They are reproduced on purpose, not fixed, so that results match ([`research/original_bugs.py`](https://github.com/p-ramcharan-dev/fastrectpack/blob/main/research/original_bugs.py) demonstrates each):
+
+- `validate_packing()` never compares the last rectangle with the others, so an overlap involving it goes undetected.
+- `MaxRectsBl` documents a smallest-x tie-break but takes the first candidate.
+- With the BBF bin heuristic, online `add_rect` returns `True`/`False` instead of the rectangle.
+
+## Limitations
+
+- Speed was measured on one Windows laptop only. Correctness is checked in CI on Linux, Windows and macOS (arm64), but speed on those systems has not been measured.
+- The package subclasses rectpack internals and pins `rectpack==0.2.2`. A new rectpack release would need re-checking.
+- An unpickled or deep-copied packer continues on the original Python code path: correct, but not accelerated.
+
+## Contributing and security
+
+Issues and pull requests are welcome; see [CONTRIBUTING.md](https://github.com/p-ramcharan-dev/fastrectpack/blob/main/CONTRIBUTING.md). The most useful report is a real workload where it is still slow. Please report security problems privately, as described in [SECURITY.md](https://github.com/p-ramcharan-dev/fastrectpack/blob/main/SECURITY.md).
+
+## Credits and licence
+
+Apache-2.0, the same licence as rectpack, of which this is a derivative work. rectpack is by SecNot. The MaxRects algorithms come from Jukka Jylänki, "A Thousand Ways to Pack the Bin" (2010). See [NOTICE](https://github.com/p-ramcharan-dev/fastrectpack/blob/main/NOTICE).

fastrectpack-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+fastrectpack/__init__.py,sha256=Vl4TSOaJuolSCu-bwAxbl1GlagsL6TuobFVOUgK3Q1U,1225
+fastrectpack/_maxrects.py,sha256=-c5p8wPvp66GodwiMX24__b8Qd9q7TN9wNu6KJhtbkM,3645
+fastrectpack/_native.cp313-win_amd64.pyd,sha256=Va3GgZhXkJFhXHxiMd5gzVqwrZqj5NtdnDs_xBwKWYI,215040
+fastrectpack/_native.cpp,sha256=IEPtqn2ZWco1jxbU6xsqWk1ZNoHovs26Io4HIAL67n4,9118
+fastrectpack-0.1.0.dist-info/METADATA,sha256=qZp0WlZLNKv2sgBu79f4wLSiOnl_oM_4JI4yJwAT_mY,10338
+fastrectpack-0.1.0.dist-info/WHEEL,sha256=bzccfTXe5NE7eB86OiS4hIwvwnRsRQgKw2c3BU4To6A,105
+fastrectpack-0.1.0.dist-info/licenses/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
+fastrectpack-0.1.0.dist-info/licenses/NOTICE,sha256=abWczgp7TPLPxsrkBfJMSZzdqINIno6YzNsVtJbjgMY,708
+fastrectpack-0.1.0.dist-info/RECORD,,

fastrectpack-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: scikit-build-core 1.1.2
+Root-Is-Purelib: false
+Tag: cp313-cp313-win_amd64
+

fastrectpack-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 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.

fastrectpack-0.1.0.dist-info/licenses/NOTICE

@@ -0,0 +1,13 @@
+fastrectpack
+Copyright 2026 Ramcharan
+
+This product is a derivative work of rectpack (https://github.com/secnot/rectpack),
+licensed under the Apache License, Version 2.0, by its author SecNot.
+
+Changes made: the MaxRects packing algorithms (MaxRectsBl, MaxRectsBssf, MaxRectsBaf,
+MaxRectsBlsf) were re-implemented in C++17 for plain Python int sizes and are exposed
+through classes that subclass the originals. All other behaviour and all other algorithms
+are the unmodified rectpack code, which is installed as a dependency and re-exported.
+
+The MaxRects family itself is described in: Jukka Jylanki, "A Thousand Ways to Pack the
+Bin - A Practical Approach to Two-Dimensional Rectangle Bin Packing" (2010).