ffpsd 0.4.6__tar.gz → 0.4.7__tar.gz

{ffpsd-0.4.6 → ffpsd-0.4.7}/CMakeLists.txt

@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.23)
 
 project(ffpsd
-    VERSION 0.4.6
+    VERSION 0.4.7
     DESCRIPTION "ffpsd library"
     LANGUAGES CXX)
 

ffpsd-0.4.7/PKG-INFO

@@ -0,0 +1,117 @@
+Metadata-Version: 2.4
+Name: ffpsd
+Version: 0.4.7
+Summary: Read and write Photoshop PSD and PSB files
+Keywords: psd,psb,photoshop,image,layers
+License-Expression: MIT
+License-File: LICENSE
+License-File: vendor/libjpeg-turbo/LICENSE.md
+License-File: vendor/libjpeg-turbo/README.ijg
+License-File: vendor/libpng/LICENSE
+License-File: vendor/libwebp/COPYING
+License-File: vendor/libwebp/PATENTS
+License-File: vendor/zlib-ng/LICENSE.md
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+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 :: Implementation :: CPython
+Classifier: Topic :: Multimedia :: Graphics
+Classifier: Topic :: Multimedia :: Graphics :: Graphics Conversion
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Project-URL: Repository, https://github.com/EnergyFlexus/ffpsd
+Requires-Python: >=3.10
+Requires-Dist: numpy>=1.22
+Provides-Extra: pil
+Requires-Dist: Pillow>=9.1; extra == "pil"
+Description-Content-Type: text/markdown
+
+# ffpsd
+
+Python bindings to [ffpsd](https://github.com/EnergyFlexus/ffpsd), a library that reads and writes Photoshop PSD
+and PSB files.
+
+```python
+import ffpsd
+import numpy as np
+
+
+def run(input_path, picture_path, output_path):
+    doc = ffpsd.Document.open(input_path)
+    width, height = doc.width, doc.height
+    print(f"{width} x {height}, {doc.depth} bit, {doc.layer_count} layers")
+
+    # The composite Photoshop saved with the file, as PNG; None when the file has none.
+    composite = doc.merged_image()
+    if composite is not None:
+        print(f"composite: {len(ffpsd.encode_png(composite))} bytes of PNG")
+
+    # Layers go from the bottom up, so the top one is -1.
+    top = doc.layer(-1)
+    print(f"top layer: {top.name}, {top.bounds.width} x {top.bounds.height}")
+
+    # A copy of it on top, half transparent, in Multiply mode.
+    copy = doc.duplicate_layer(-1)
+    copy.name = "Copy"
+    copy.opacity = 128
+    copy.blend_key = ffpsd.fourcc("mul ")
+
+    # A PNG, JPEG or WebP as a layer in the document's mode and depth, 50 px from the corner, half the canvas in size, mirrored.
+    image = ffpsd.load_picture(picture_path, doc.color_mode, doc.depth)
+    picture = doc.add_layer("Picture", image, 50, 50)
+    picture.resize(width // 2, height // 2)
+    picture.flip(ffpsd.FlipDirection.HORIZONTAL)
+
+    # A mask that hides a 100 x 100 square in the picture's corner and shows the rest.
+    picture.set_mask(np.zeros((100, 100), np.uint8), 50, 50, 255)
+
+    # A Levels layer over everything that brightens the midtones.
+    doc.add_levels_layer("Levels", ffpsd.Levels(channels=[ffpsd.LevelsChannel(gamma=1.5)]))
+
+    # 100 px more canvas on every side, then save, each channel RLE or raw, whichever is smaller.
+    doc.resize_canvas(width + 200, height + 200, ffpsd.Anchor.CENTER)
+    doc.save(output_path, ffpsd.Compression.RLE_OR_RAW)
+    print(f"saved {doc.layer_count} layers to {output_path}")
+```
+
+## What it does for now
+
+* PSD and PSB, and either into the other; RGB and gray documents, and either into the other.
+* Layers: raster layers, groups, the background and Levels adjustments; added, copied from this or another
+  document, moved and removed; name, opacity, visibility, clipping and blend mode; pixels in and out.
+* Pixel masks, read, set and removed.
+* The canvas and the layers resized, turned and flipped; the canvas grown or cut from any anchor.
+* The composite the file stores, read and replaced; resolution and version info.
+* Every image resource and tagged block, raw, for what ffpsd does not interpret itself.
+* PNG, JPEG and WebP in and out.
+
+## In Python
+
+* Pixels are NumPy arrays, planar as PSD keeps them: `(channels, height, width)`, uint8, uint16 or float32 by
+  the depth. Arrays ffpsd gives own their memory without a copy; one it takes is copied only when it is not
+  C-contiguous, so `pixels.transpose(2, 0, 1)` of an interleaved picture works as is.
+* Calls that take time, such as saving, pixels in and out and resizing, release the GIL, so separate documents
+  work in threads at once. A document belongs to one thread at a time: touching one that another thread is
+  working on raises `ffpsd.InvalidOperationError`.
+* Errors are `ffpsd.Error` and also the built-in exception they mean: `ValueError`, `IndexError`, `OSError`,
+  `RuntimeError` or `NotImplementedError`.
+* A layer removed from its document raises on use instead of crashing.
+* With `pip install ffpsd[pil]`, `ffpsd.from_pil` and `ffpsd.to_pil` take and give Pillow images.
+* Type stubs come with the package.
+
+More in the [repository](https://github.com/EnergyFlexus/ffpsd): building from source and the
+[roadmap](https://github.com/EnergyFlexus/ffpsd/blob/main/ROADMAP.md).
+
+## License
+
+MIT. The vendored libraries built in keep their own permissive licenses, which the package carries.

{ffpsd-0.4.6 → ffpsd-0.4.7}/README.md

@@ -1,16 +1,41 @@
 # ffpsd
 
-Read and write Photoshop PSD and PSB files, with two APIs from one build:
+Read and write Photoshop PSD and PSB files from C++, C, Rust and Python:
 
 * `ffpsd/ffpsd.hpp` - C++
 * `ffpsd/c_api.h` - C, for other languages and toolchains
+* Rust - the [ffpsd](https://crates.io/crates/ffpsd) crate, sources in [bindings/rust/](bindings/rust/ffpsd/README.md)
+* Python - the [ffpsd](https://pypi.org/project/ffpsd/) package, sources in [bindings/python/](bindings/python/README.md)
 
 Until 1.0.0 the APIs are not stable: a release may break source and binary compatibility.
-
-Bindings, built from this repository:
-
-* Rust - [ffpsd](https://crates.io/crates/ffpsd) on crates.io, sources in [bindings/rust/](bindings/rust/ffpsd/README.md)
-* Python - [ffpsd](https://pypi.org/project/ffpsd/) on PyPI, sources in [bindings/python/](bindings/python/README.md)
+What comes next: [ROADMAP.md](ROADMAP.md).
+
+## What it does for now
+
+* PSD and PSB, and either into the other; RGB and gray documents, and either into the other.
+* Layers: raster layers, groups, the background and Levels adjustments; added, copied from this or another
+  document, moved and removed; name, opacity, visibility, clipping and blend mode; pixels in and out.
+* Pixel masks, read, set and removed.
+* The canvas and the layers resized, turned and flipped; the canvas grown or cut from any anchor.
+* The composite the file stores, read and replaced; resolution and version info.
+* Every image resource and tagged block, raw, for what ffpsd does not interpret itself.
+* PNG, JPEG and WebP in and out.
+
+## How it works
+
+* Single-threaded, with no global state: a document belongs to one thread at a time, and separate documents
+  work in separate threads at once, so a batch of files spreads over every core.
+* Nothing is lost: blocks, resources and channels ffpsd does not interpret are written back byte for byte,
+  and a document saved unchanged is the file it was read from.
+* Lazy: a channel is decoded when its pixels are asked for and written back as stored until they change,
+  so opening and saving cost little more than the file's size.
+* In memory: opening reads the whole file and closes it, so the file is not locked while you work; saving
+  builds the new file in memory and writes it once. The price is memory: about the
+  file's size for the document, twice that while opening or saving, plus any pixels you decode.
+* Self-contained: libpng, zlib-ng, libjpeg-turbo and libwebp are built in under renamed symbols, so other
+  copies in the same program do not clash, and PNG, JPEG and WebP load and save with nothing else installed.
+
+## Getting the sources
 
 Code style: [CONTRIBUTING.md](CONTRIBUTING.md). Programs in C++, C, Rust and Python:
 [examples/](examples/README.md).

ffpsd-0.4.7/ROADMAP.md

@@ -0,0 +1,47 @@
+# Roadmap
+
+What comes next, roughly in this order; no dates. Until 1.0.0 the APIs may still change.
+
+## 1. ZIP compression
+
+Decode and write channels compressed with ZIP and ZIP with prediction, as Photoshop
+writes 16 and 32 bit documents and some layers. Today such channels are kept as read,
+and reading their pixels throws.
+
+## 2. 16 bit
+
+Every operation at 16 bit as at 8: layers, masks, the composite, resizing, color
+conversion, PSB. Today 16 bit is partial.
+
+## 3. CMYK
+
+Read, edit and write CMYK documents: pixels and the composite as Photoshop stores them,
+conversion to and from RGB and gray, PNG and JPEG through that conversion. Today CMYK
+documents open and keep their layers, but only RGB and gray convert.
+
+## 4. Layer kinds
+
+Tell the kinds of layers apart, at least by the blocks they hold: text, shape, smart
+object, fill (solid color, gradient, pattern), artboard, besides the raster, group and
+adjustment layers known today. Reading what is inside them comes later.
+
+## 5. Composite of raster layers
+
+Render the picture from the raster layers: visibility, opacity and fill opacity, blend
+modes, clipping masks, pixel masks, groups. The composite of a saved document is then
+up to date, so viewers other than Photoshop show the edits. Text, effects and
+adjustments are not rendered.
+
+## 6. Vector masks
+
+Read a layer's vector mask as paths, keep it right through every change of the canvas
+and the layer (moving, resizing, turning, flipping), and render it into the composite.
+Today vector masks are kept as read and survive resizing the document, but the other
+changes throw on such a layer, as do setting and removing its pixel mask.
+
+## 7. Descriptors
+
+Read and write action descriptors, the typed key and value trees in which Photoshop
+keeps text, smart objects, layer effects, fill layers and most adjustments, written
+back byte for byte when unchanged. This is what reading those layers rests on. Today
+their blocks are kept as raw bytes.

ffpsd-0.4.7/bindings/python/README.md

@@ -0,0 +1,79 @@
+# ffpsd
+
+Python bindings to [ffpsd](https://github.com/EnergyFlexus/ffpsd), a library that reads and writes Photoshop PSD
+and PSB files.
+
+```python
+import ffpsd
+import numpy as np
+
+
+def run(input_path, picture_path, output_path):
+    doc = ffpsd.Document.open(input_path)
+    width, height = doc.width, doc.height
+    print(f"{width} x {height}, {doc.depth} bit, {doc.layer_count} layers")
+
+    # The composite Photoshop saved with the file, as PNG; None when the file has none.
+    composite = doc.merged_image()
+    if composite is not None:
+        print(f"composite: {len(ffpsd.encode_png(composite))} bytes of PNG")
+
+    # Layers go from the bottom up, so the top one is -1.
+    top = doc.layer(-1)
+    print(f"top layer: {top.name}, {top.bounds.width} x {top.bounds.height}")
+
+    # A copy of it on top, half transparent, in Multiply mode.
+    copy = doc.duplicate_layer(-1)
+    copy.name = "Copy"
+    copy.opacity = 128
+    copy.blend_key = ffpsd.fourcc("mul ")
+
+    # A PNG, JPEG or WebP as a layer in the document's mode and depth, 50 px from the corner, half the canvas in size, mirrored.
+    image = ffpsd.load_picture(picture_path, doc.color_mode, doc.depth)
+    picture = doc.add_layer("Picture", image, 50, 50)
+    picture.resize(width // 2, height // 2)
+    picture.flip(ffpsd.FlipDirection.HORIZONTAL)
+
+    # A mask that hides a 100 x 100 square in the picture's corner and shows the rest.
+    picture.set_mask(np.zeros((100, 100), np.uint8), 50, 50, 255)
+
+    # A Levels layer over everything that brightens the midtones.
+    doc.add_levels_layer("Levels", ffpsd.Levels(channels=[ffpsd.LevelsChannel(gamma=1.5)]))
+
+    # 100 px more canvas on every side, then save, each channel RLE or raw, whichever is smaller.
+    doc.resize_canvas(width + 200, height + 200, ffpsd.Anchor.CENTER)
+    doc.save(output_path, ffpsd.Compression.RLE_OR_RAW)
+    print(f"saved {doc.layer_count} layers to {output_path}")
+```
+
+## What it does for now
+
+* PSD and PSB, and either into the other; RGB and gray documents, and either into the other.
+* Layers: raster layers, groups, the background and Levels adjustments; added, copied from this or another
+  document, moved and removed; name, opacity, visibility, clipping and blend mode; pixels in and out.
+* Pixel masks, read, set and removed.
+* The canvas and the layers resized, turned and flipped; the canvas grown or cut from any anchor.
+* The composite the file stores, read and replaced; resolution and version info.
+* Every image resource and tagged block, raw, for what ffpsd does not interpret itself.
+* PNG, JPEG and WebP in and out.
+
+## In Python
+
+* Pixels are NumPy arrays, planar as PSD keeps them: `(channels, height, width)`, uint8, uint16 or float32 by
+  the depth. Arrays ffpsd gives own their memory without a copy; one it takes is copied only when it is not
+  C-contiguous, so `pixels.transpose(2, 0, 1)` of an interleaved picture works as is.
+* Calls that take time, such as saving, pixels in and out and resizing, release the GIL, so separate documents
+  work in threads at once. A document belongs to one thread at a time: touching one that another thread is
+  working on raises `ffpsd.InvalidOperationError`.
+* Errors are `ffpsd.Error` and also the built-in exception they mean: `ValueError`, `IndexError`, `OSError`,
+  `RuntimeError` or `NotImplementedError`.
+* A layer removed from its document raises on use instead of crashing.
+* With `pip install ffpsd[pil]`, `ffpsd.from_pil` and `ffpsd.to_pil` take and give Pillow images.
+* Type stubs come with the package.
+
+More in the [repository](https://github.com/EnergyFlexus/ffpsd): building from source and the
+[roadmap](https://github.com/EnergyFlexus/ffpsd/blob/main/ROADMAP.md).
+
+## License
+
+MIT. The vendored libraries built in keep their own permissive licenses, which the package carries.

{ffpsd-0.4.6 → ffpsd-0.4.7}/bindings/python/ffpsd/_pil.py

@@ -7,7 +7,7 @@ from typing import TYPE_CHECKING
 import numpy as np
 
 from ._errors import InvalidArgumentError
-from ._ffpsd import ColorMode
+from ._ffpsd import ColorMode  # pyright: ignore[reportMissingImports]
 
 if TYPE_CHECKING:
     from numpy.typing import NDArray
@@ -45,7 +45,7 @@ def from_pil(image: Image, color_mode: ColorMode = ColorMode.RGB, depth: int = 8
         pixels = pixels[..., None]
     planes = pixels.transpose(2, 0, 1)
     if depth == 16:
-        planes = planes.astype(np.uint16) * 257
+        planes = planes.astype(np.uint16) * np.uint16(257)
     return np.ascontiguousarray(planes)
 
 

{ffpsd-0.4.6 → ffpsd-0.4.7}/bindings/python/src/common.cpp

@@ -6,6 +6,18 @@
 
 namespace ffpsd_python
 {
+    ffpsd::Document& DocumentObject::Get()
+    {
+        return const_cast<ffpsd::Document&>(std::as_const(*this).Get());
+    }
+
+    const ffpsd::Document& DocumentObject::Get() const
+    {
+        if (busy)
+            throw std::logic_error("ffpsd: the document is used by another thread");
+        return document;
+    }
+
     std::uint64_t DocumentObject::Serial(const ffpsd::Layer* layer)
     {
         const auto [at, added] = serials.try_emplace(layer, next_serial);
@@ -25,7 +37,7 @@ namespace ffpsd_python
 
     std::size_t DocumentObject::Index(std::int64_t index) const
     {
-        const auto count = static_cast<std::int64_t>(document.GetLayerCount());
+        const auto count = static_cast<std::int64_t>(Get().GetLayerCount());
         const std::int64_t at = index < 0 ? index + count : index;
         if (at < 0 || at >= count)
             throw std::out_of_range("ffpsd: layer index " + std::to_string(index) + " of " + std::to_string(count));
@@ -34,6 +46,7 @@ namespace ffpsd_python
 
     ffpsd::Layer& LayerObject::Get() const
     {
+        document->Get();
         const auto at = document->serials.find(layer);
         if (at == document->serials.end() || at->second != serial)
             throw std::logic_error("ffpsd: the layer was removed from its document");

{ffpsd-0.4.6 → ffpsd-0.4.7}/bindings/python/src/common.hpp

@@ -54,11 +54,18 @@ namespace ffpsd_python
         std::unordered_map<const ffpsd::Layer*, std::uint64_t> serials;
         std::uint64_t next_serial = 1;
 
+        // Set while a call works on the document without the GIL; read and written only with the GIL held.
+        mutable bool busy = false;
+
         explicit DocumentObject(ffpsd::Document&& value)
             : document(std::move(value))
         {
         }
 
+        // Throws std::logic_error while another thread works on the document, instead of racing it.
+        ffpsd::Document& Get();
+        const ffpsd::Document& Get() const;
+
         std::uint64_t Serial(const ffpsd::Layer* layer);
 
         // After a layer is destroyed: forgets every serial whose layer the document no longer has.
@@ -81,6 +88,24 @@ namespace ffpsd_python
 
     LayerObject MakeLayer(DocumentObject& document, ffpsd::Layer* layer);
 
+    // Runs work without the GIL, with the document busy meanwhile; work reaches the document directly, not through Get().
+    template <class Work> auto WithoutGil(const DocumentObject& document, Work&& work)
+    {
+        document.Get();
+        document.busy = true;
+        struct Done
+        {
+            const DocumentObject& document;
+            ~Done()
+            {
+                document.busy = false;
+            }
+        } done{document};
+        // Destroyed before done: the GIL is back when busy clears.
+        nb::gil_scoped_release release;
+        return work();
+    }
+
     // Paths are UTF-8 for ffpsd on every system.
     std::string ToUtf8(const std::filesystem::path& path);
 

{ffpsd-0.4.6 → ffpsd-0.4.7}/bindings/python/src/document.cpp

@@ -50,162 +50,169 @@ namespace ffpsd_python
             .def(
                 "save",
                 [](const DocumentObject& self, const std::filesystem::path& path, ffpsd::Compression compression) {
-                    self.document.Save(ToUtf8(path), compression);
+                    const std::string utf8 = ToUtf8(path);
+                    WithoutGil(self, [&] { self.document.Save(utf8, compression); });
                 },
                 "path"_a, "compression"_a = ffpsd::Compression::kDefault)
             .def(
                 "to_bytes",
                 [](const DocumentObject& self, ffpsd::Compression compression) {
-                    const std::vector<std::uint8_t> data = self.document.Save(compression);
+                    const std::vector<std::uint8_t> data = WithoutGil(self, [&] { return self.document.Save(compression); });
                     return ToBytes(data.data(), data.size());
                 },
                 "compression"_a = ffpsd::Compression::kDefault)
 
-            .def_prop_ro("width", [](const DocumentObject& self) { return self.document.GetWidth(); })
-            .def_prop_ro("height", [](const DocumentObject& self) { return self.document.GetHeight(); })
-            .def_prop_ro("channel_count", [](const DocumentObject& self) { return self.document.GetChannelCount(); })
-            .def_prop_ro("depth", [](const DocumentObject& self) { return self.document.GetDepth(); })
-            .def_prop_ro("color_mode", [](const DocumentObject& self) { return self.document.GetColorMode(); })
+            .def_prop_ro("width", [](const DocumentObject& self) { return self.Get().GetWidth(); })
+            .def_prop_ro("height", [](const DocumentObject& self) { return self.Get().GetHeight(); })
+            .def_prop_ro("channel_count", [](const DocumentObject& self) { return self.Get().GetChannelCount(); })
+            .def_prop_ro("depth", [](const DocumentObject& self) { return self.Get().GetDepth(); })
+            .def_prop_ro("color_mode", [](const DocumentObject& self) { return self.Get().GetColorMode(); })
             .def_prop_rw(
-                "psb", [](const DocumentObject& self) { return self.document.IsPsb(); },
-                [](DocumentObject& self, bool psb) { self.document.SetPsb(psb); })
+                "psb", [](const DocumentObject& self) { return self.Get().IsPsb(); },
+                [](DocumentObject& self, bool psb) { self.Get().SetPsb(psb); })
             .def_prop_rw(
-                "has_real_merged_data", [](const DocumentObject& self) { return self.document.HasRealMergedData(); },
-                [](DocumentObject& self, bool value) { self.document.SetHasRealMergedData(value); })
+                "has_real_merged_data", [](const DocumentObject& self) { return self.Get().HasRealMergedData(); },
+                [](DocumentObject& self, bool value) { self.Get().SetHasRealMergedData(value); })
             .def_prop_rw(
-                "version_info", [](const DocumentObject& self) { return self.document.GetVersionInfo(); },
-                [](DocumentObject& self, const ffpsd::VersionInfo& value) { self.document.SetVersionInfo(value); })
+                "version_info", [](const DocumentObject& self) { return self.Get().GetVersionInfo(); },
+                [](DocumentObject& self, const ffpsd::VersionInfo& value) { self.Get().SetVersionInfo(value); })
             .def_prop_rw(
-                "resolution_info", [](const DocumentObject& self) { return self.document.GetResolutionInfo(); },
-                [](DocumentObject& self, const ffpsd::ResolutionInfo& value) { self.document.SetResolutionInfo(value); })
+                "resolution_info", [](const DocumentObject& self) { return self.Get().GetResolutionInfo(); },
+                [](DocumentObject& self, const ffpsd::ResolutionInfo& value) { self.Get().SetResolutionInfo(value); })
 
             .def(
                 "resize_canvas",
                 [](DocumentObject& self, std::uint32_t width, std::uint32_t height, ffpsd::Anchor anchor) {
-                    self.document.ResizeCanvas(width, height, anchor);
+                    WithoutGil(self, [&] { self.document.ResizeCanvas(width, height, anchor); });
                 },
                 "width"_a, "height"_a, "anchor"_a = ffpsd::Anchor::kCenter)
             .def(
                 "resize",
                 [](DocumentObject& self, std::uint32_t width, std::uint32_t height, ffpsd::ResampleFilter filter) {
-                    self.document.Resize(width, height, filter);
+                    WithoutGil(self, [&] { self.document.Resize(width, height, filter); });
                 },
                 "width"_a, "height"_a, "filter"_a = ffpsd::ResampleFilter::kBicubic)
             .def(
-                "flip_canvas", [](DocumentObject& self, ffpsd::FlipDirection direction) { self.document.FlipCanvas(direction); },
+                "flip_canvas",
+                [](DocumentObject& self, ffpsd::FlipDirection direction) {
+                    WithoutGil(self, [&] { self.document.FlipCanvas(direction); });
+                },
                 "direction"_a)
             .def(
-                "rotate_canvas", [](DocumentObject& self, ffpsd::Rotation rotation) { self.document.RotateCanvas(rotation); }, "rotation"_a)
+                "rotate_canvas",
+                [](DocumentObject& self, ffpsd::Rotation rotation) { WithoutGil(self, [&] { self.document.RotateCanvas(rotation); }); },
+                "rotation"_a)
             .def(
-                "convert_color_mode", [](DocumentObject& self, ffpsd::ColorMode color_mode) { self.document.ConvertColorMode(color_mode); },
+                "convert_color_mode",
+                [](DocumentObject& self, ffpsd::ColorMode color_mode) {
+                    WithoutGil(self, [&] { self.document.ConvertColorMode(color_mode); });
+                },
                 "color_mode"_a)
 
             .def_prop_ro(
                 "image_resources",
                 [](const DocumentObject& self) {
                     std::vector<ffpsd::ImageResource> resources;
-                    for (std::size_t i = 0; i < self.document.GetImageResourceCount(); ++i)
-                        resources.push_back(*self.document.GetImageResourceByIndex(i));
+                    for (std::size_t i = 0; i < self.Get().GetImageResourceCount(); ++i)
+                        resources.push_back(*self.Get().GetImageResourceByIndex(i));
                     return resources;
                 })
             .def(
                 "find_image_resource",
-                [](const DocumentObject& self, std::uint16_t id) { return Copy(self.document.GetImageResourceById(id)); }, "id"_a)
+                [](const DocumentObject& self, std::uint16_t id) { return Copy(self.Get().GetImageResourceById(id)); }, "id"_a)
             .def(
                 "set_image_resource",
-                [](DocumentObject& self, const ffpsd::ImageResource& resource) { self.document.SetImageResource(resource); }, "resource"_a)
+                [](DocumentObject& self, const ffpsd::ImageResource& resource) { self.Get().SetImageResource(resource); }, "resource"_a)
             .def(
-                "remove_image_resource", [](DocumentObject& self, std::uint16_t id) { return self.document.RemoveImageResource(id); },
-                "id"_a)
+                "remove_image_resource", [](DocumentObject& self, std::uint16_t id) { return self.Get().RemoveImageResource(id); }, "id"_a)
 
-            .def_prop_ro("layer_count", [](const DocumentObject& self) { return self.document.GetLayerCount(); })
+            .def_prop_ro("layer_count", [](const DocumentObject& self) { return self.Get().GetLayerCount(); })
             .def_prop_ro(
                 "layers",
                 [](DocumentObject& self) {
                     std::vector<LayerObject> layers;
-                    for (std::size_t i = 0; i < self.document.GetLayerCount(); ++i)
-                        layers.push_back(MakeLayer(self, self.document.GetLayerByIndex(i)));
+                    for (std::size_t i = 0; i < self.Get().GetLayerCount(); ++i)
+                        layers.push_back(MakeLayer(self, self.Get().GetLayerByIndex(i)));
                     return layers;
                 })
             .def(
                 "layer",
-                [](DocumentObject& self, std::int64_t index) { return MakeLayer(self, self.document.GetLayerByIndex(self.Index(index))); },
+                [](DocumentObject& self, std::int64_t index) { return MakeLayer(self, self.Get().GetLayerByIndex(self.Index(index))); },
                 "index"_a)
             .def(
                 "find_layer_index",
-                [](const DocumentObject& self, const LayerObject& layer) { return self.document.FindLayerIndex(layer.Get()); }, "layer"_a)
+                [](const DocumentObject& self, const LayerObject& layer) { return self.Get().FindLayerIndex(layer.Get()); }, "layer"_a)
             .def(
                 "add_layer",
                 [](DocumentObject& self, const std::string& name, const std::optional<PixelArray>& pixels, std::int32_t top,
                    std::int32_t left) {
-                    return MakeLayer(self, self.document.AddLayer(name, ToView(pixels, self.document.GetColorMode()), top, left));
+                    const ffpsd::ImageView view = ToView(pixels, self.Get().GetColorMode());
+                    return MakeLayer(self, WithoutGil(self, [&] { return self.document.AddLayer(name, view, top, left); }));
                 },
                 "name"_a, "pixels"_a = nb::none(), "top"_a = 0, "left"_a = 0)
             .def(
                 "add_background_layer",
                 [](DocumentObject& self, const std::string& name, const std::optional<PixelArray>& pixels) {
-                    return MakeLayer(self, self.document.AddBackgroundLayer(name, ToView(pixels, self.document.GetColorMode())));
+                    const ffpsd::ImageView view = ToView(pixels, self.Get().GetColorMode());
+                    return MakeLayer(self, WithoutGil(self, [&] { return self.document.AddBackgroundLayer(name, view); }));
                 },
                 "name"_a, "pixels"_a = nb::none())
             .def(
-                "set_background_layer",
-                [](DocumentObject& self, std::int64_t index) { self.document.SetBackgroundLayer(self.Index(index)); }, "index"_a)
-            .def("unset_background_layer", [](DocumentObject& self) { return self.document.UnsetBackgroundLayer(); })
+                "set_background_layer", [](DocumentObject& self, std::int64_t index) { self.Get().SetBackgroundLayer(self.Index(index)); },
+                "index"_a)
+            .def("unset_background_layer", [](DocumentObject& self) { return self.Get().UnsetBackgroundLayer(); })
             .def(
-                "add_group", [](DocumentObject& self, const std::string& name) { return MakeLayer(self, self.document.AddGroup(name)); },
+                "add_group", [](DocumentObject& self, const std::string& name) { return MakeLayer(self, self.Get().AddGroup(name)); },
                 "name"_a)
             .def(
                 "add_levels_layer",
                 [](DocumentObject& self, const std::string& name, const std::optional<ffpsd::LevelsInfo>& levels) {
-                    return MakeLayer(self, self.document.AddAdjustmentLayer(name, levels.value_or(ffpsd::LevelsInfo())));
+                    return MakeLayer(self, self.Get().AddAdjustmentLayer(name, levels.value_or(ffpsd::LevelsInfo())));
                 },
                 "name"_a, "levels"_a = nb::none())
             .def(
                 "add_layer_copy",
-                [](DocumentObject& self, const LayerObject& source) { return MakeLayer(self, self.document.AddLayerCopy(source.Get())); },
+                [](DocumentObject& self, const LayerObject& source) { return MakeLayer(self, self.Get().AddLayerCopy(source.Get())); },
                 "source"_a)
             .def(
                 "duplicate_layer",
                 [](DocumentObject& self, std::int64_t index) {
-                    return MakeLayer(self, self.document.AddLayerCopy(*self.document.GetLayerByIndex(self.Index(index))));
+                    return MakeLayer(self, self.Get().AddLayerCopy(*self.Get().GetLayerByIndex(self.Index(index))));
                 },
                 "index"_a)
             .def(
                 "remove_layer",
                 [](DocumentObject& self, std::int64_t index) {
-                    self.document.RemoveLayer(self.Index(index));
+                    self.Get().RemoveLayer(self.Index(index));
                     self.ForgetRemoved();
                 },
                 "index"_a)
             .def(
                 "move_layer",
-                [](DocumentObject& self, std::int64_t index, std::int64_t to) {
-                    self.document.MoveLayer(self.Index(index), self.Index(to));
-                },
+                [](DocumentObject& self, std::int64_t index, std::int64_t to) { self.Get().MoveLayer(self.Index(index), self.Index(to)); },
                 "index"_a, "to"_a)
 
             .def_prop_ro(
                 "tagged_blocks",
                 [](const DocumentObject& self) {
                     std::vector<ffpsd::TaggedBlock> blocks;
-                    for (std::size_t i = 0; i < self.document.GetTaggedBlockCount(); ++i)
-                        blocks.push_back(*self.document.GetTaggedBlockByIndex(i));
+                    for (std::size_t i = 0; i < self.Get().GetTaggedBlockCount(); ++i)
+                        blocks.push_back(*self.Get().GetTaggedBlockByIndex(i));
                     return blocks;
                 })
             .def(
                 "find_tagged_block",
-                [](const DocumentObject& self, std::uint32_t key) { return Copy(self.document.GetTaggedBlockByKey(key)); }, "key"_a)
+                [](const DocumentObject& self, std::uint32_t key) { return Copy(self.Get().GetTaggedBlockByKey(key)); }, "key"_a)
             .def(
-                "set_tagged_block", [](DocumentObject& self, const ffpsd::TaggedBlock& block) { self.document.SetTaggedBlock(block); },
+                "set_tagged_block", [](DocumentObject& self, const ffpsd::TaggedBlock& block) { self.Get().SetTaggedBlock(block); },
                 "block"_a)
             .def(
-                "remove_tagged_block", [](DocumentObject& self, std::uint32_t key) { return self.document.RemoveTaggedBlock(key); },
-                "key"_a)
+                "remove_tagged_block", [](DocumentObject& self, std::uint32_t key) { return self.Get().RemoveTaggedBlock(key); }, "key"_a)
 
             .def(
                 "merged_image",
                 [](const DocumentObject& self) -> std::optional<NumpyArray> {
-                    ffpsd::Image image = self.document.GetMergedImage();
+                    ffpsd::Image image = WithoutGil(self, [&] { return self.document.GetMergedImage(); });
                     if (image.IsEmpty())
                         return std::nullopt;
                     return ToArray(std::move(image));
@@ -213,18 +220,21 @@ namespace ffpsd_python
             .def(
                 "merged_image_info",
                 [](const DocumentObject& self) -> std::optional<ffpsd::ImageInfo> {
-                    const ffpsd::ImageInfo info = self.document.GetMergedImageInfo();
+                    const ffpsd::ImageInfo info = self.Get().GetMergedImageInfo();
                     return info.IsEmpty() ? std::nullopt : std::optional<ffpsd::ImageInfo>(info);
                 })
             .def(
                 "set_merged_image",
                 [](DocumentObject& self, const PixelArray& pixels) {
-                    self.document.SetMergedImage(ToView(pixels, self.document.GetColorMode()));
+                    const ffpsd::ImageView view = ToView(pixels, self.Get().GetColorMode());
+                    WithoutGil(self, [&] { self.document.SetMergedImage(view); });
                 },
                 "pixels"_a)
-            .def_prop_ro("merged_compression", [](const DocumentObject& self) { return self.document.GetMergedCompression(); })
+            .def_prop_ro("merged_compression", [](const DocumentObject& self) { return self.Get().GetMergedCompression(); })
 
             .def("__repr__", [](const DocumentObject& self) {
+                if (self.busy)
+                    return std::string("<ffpsd.Document, used by another thread>");
                 const ffpsd::Document& d = self.document;
                 return "<ffpsd.Document " + std::to_string(d.GetWidth()) + " x " + std::to_string(d.GetHeight()) + ", " +
                        std::to_string(d.GetDepth()) + " bit, " + std::to_string(d.GetLayerCount()) + " layers>";