psdparse 0.8.0__tar.gz → 0.8.1__tar.gz

{psdparse-0.8.0 → psdparse-0.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: psdparse
-Version: 0.8.0
+Version: 0.8.1
 Summary: Fast PSD (Photoshop) reader/writer — C++17 core with pybind11 bindings
 Keywords: psd,photoshop,parser,image,graphics
 Author-Email: wamsoft <wtnbgo@gmail.com>

{psdparse-0.8.0 → psdparse-0.8.1}/docs/PYTHON_API.md

@@ -331,6 +331,9 @@ new_i = p.copy_layer_from(src, j, dest_index=-1)  # copy layer j from another PS
 ```
 
 Notes:
+- `duplicate_layer` / `copy_layer_from` assign the copy a **fresh `layer_id`**
+  (max existing lyid + 1, like Photoshop) so layer IDs stay unique within the
+  document; the `lyid` additional-info block is rewritten on save.
 - `delete_layer` / `duplicate_layer` on a single layer are exact. Deleting **one
   half of a group's FOLDER/HIDDEN divider pair unbalances the group** — delete
   whole groups (both dividers + contents) for clean nesting. (Unbalanced results

{psdparse-0.8.0 → psdparse-0.8.1}/docs/ROADMAP.md

@@ -3,12 +3,12 @@
 For a feature-by-feature account of what is and isn't supported today, see
 [SUPPORT.md](SUPPORT.md). This file tracks planned work.
 
-## Current state (2026-08-02, v0.8.0)
+## Current state (2026-08-12, v0.8.1)
 
 - ✅ Pure C++17 parser (no Boost)
 - ✅ mmap + StreamReader / Source abstraction
 - ✅ Python bindings (pybind11)
-- ✅ pytest regression suite (137 tests)
+- ✅ pytest regression suite (140 tests)
 - ✅ Python composite recipes (`examples/`) + `set_merged_image`; layer comps exposed (`layer.comp_states`)
 - ✅ Round-trip PSD save (byte-identical)
 - ✅ Edit & save: structure / pixels / mask / parameters / effects / text / new-from-scratch (E1–E6, byte-exact re-serialization)
@@ -91,6 +91,20 @@ Editing text content/style means writing the `TySh` block back: re-serializing t
 
 ## Other future work
 
+- ✅ **`duplicate_layer` assigns a fresh `lyid`.** *Done 2026-08-12.* The
+  duplicated layer used to copy the source's `lyid` (layer ID) verbatim, so the
+  output PSD contained duplicate layer IDs — Photoshop itself assigns a *new*
+  ID when duplicating. Downstream tools that use `lyid` as a persistent layer
+  identity (e.g. elements_console's uitool reference resolution) then saw
+  ambiguous matches. Fix (`psdfile.cpp`): `assignFreshLayerId` sets
+  `layerId = max existing lyid + 1` and replaces (or appends) the `lyid`
+  additional-info entry on the copy, flipping `useRawBytes=false` so save
+  re-serializes it; applied in both `duplicateLayer` and `copyLayerFrom` (the
+  latter picks an ID unique within the *destination* document). `add_layer`
+  already picked max+1 — verified. Tests (`tests/test_edit.py`): duplicate →
+  all `layer.layer_id` distinct → save → reload → still distinct; double
+  duplicate cross-checked via psd-tools tagged blocks; `copy_layer_from`
+  uniqueness in the destination.
 - ✅ **Text layer content extraction (`TySh` type-tool additional info).** *Done 2026-07-27.* `lay.text` returns `{"text", "orientation", "justification", "transform", "runs":[{"length","font","size_px","color","tracking","kerning","auto_kerning"}]}` (or `None` for non-text layers). Implementation: `psddesc` now reads `tdta` raw data (length-prefixed), `loadLayerTypeTool` (`psdlayer.cpp`) parses the `TySh` header + text descriptor, and `psdengine.cpp` parses the embedded Adobe *EngineData* mini-language (FontSet / StyleRun / ParagraphRun) into per-run styling. Validated against `tests/data/fontsample.psd` (multi-font/size/color, **vertical**, emoji, tracking) — see `tests/test_text.py`.
 
   **Deferred (need targeted sample PSDs, next turn):**

{psdparse-0.8.0 → psdparse-0.8.1}/psdparse/psdfile.cpp

@@ -321,6 +321,38 @@ bool PSDFile::setAdditionalInfoBytes(int index, int key, const uint8_t *data, in
 
 // --- 構造編集 --------------------------------------------------------------
 
+namespace {
+
+// 文書内の既存 lyid の最大値 + 1 (lyid 無しレイヤは layerId<=0 なので無視される)。
+int nextLayerId(const std::vector<LayerInfo> &layers) {
+  int maxId = 0;
+  for (const auto &l : layers) if (l.layerId > maxId) maxId = l.layerId;
+  return maxId + 1;
+}
+
+// レイヤに新しい lyid を割り当て、extra data の 'lyid' ブロックも新値で置き換える。
+// Photoshop は複製時に新 ID を振るので、複製系 API はこれを通す。
+void assignFreshLayerId(LayerInfo &lay, int newId) {
+  lay.layerId = newId;
+  auto buf = std::make_shared<std::vector<uint8_t>>();
+  buf->push_back((uint8_t)(newId >> 24)); buf->push_back((uint8_t)(newId >> 16));
+  buf->push_back((uint8_t)(newId >> 8));  buf->push_back((uint8_t)(newId & 0xff));
+  LayerExtraData &ex = lay.extraData;
+  for (auto &a : ex.additionalLayers) {
+    if (a.key == 'lyid') {
+      delete a.data;
+      a.data = new VectorReader(buf);
+      a.size = 4;
+      ex.useRawBytes = false;
+      return;
+    }
+  }
+  ex.additionalLayers.push_back(AdditionalLayerInfo(0, 'lyid', 4, new VectorReader(buf)));
+  ex.useRawBytes = false;
+}
+
+}  // anonymous namespace
+
 bool PSDFile::deleteLayer(int index) {
   if (index < 0 || index >= (int)layerList.size()) return false;
   layerList.erase(layerList.begin() + index);
@@ -342,6 +374,7 @@ bool PSDFile::moveLayer(int from, int to) {
 int PSDFile::duplicateLayer(int index) {
   if (index < 0 || index >= (int)layerList.size()) return -1;
   LayerInfo copy = layerList[(size_t)index];
+  assignFreshLayerId(copy, nextLayerId(layerList));  // Photoshop 同様、複製は新 ID
   layerList.insert(layerList.begin() + index + 1, copy);
   layersDirty = true;
   return index + 1;
@@ -352,6 +385,7 @@ int PSDFile::copyLayerFrom(const PSDFile &src, int srcIndex, int destIndex) {
   LayerInfo copy = src.layerList[(size_t)srcIndex]; // channel/extra は src を参照
   copy.owner  = this;   // owner はどこからも参照されないが整合のため付け替え
   copy.parent = nullptr;
+  assignFreshLayerId(copy, nextLayerId(layerList)); // 取り込み先の文書内で一意な ID
   int pos = (destIndex < 0 || destIndex > (int)layerList.size())
               ? (int)layerList.size() : destIndex;
   layerList.insert(layerList.begin() + pos, copy);

{psdparse-0.8.0 → psdparse-0.8.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "psdparse"
-version = "0.8.0"
+version = "0.8.1"
 description = "Fast PSD (Photoshop) reader/writer — C++17 core with pybind11 bindings"
 readme = "README.md"
 requires-python = ">=3.9"

{psdparse-0.8.0 → psdparse-0.8.1}/python/psdparse_module.cpp

@@ -922,7 +922,8 @@ PYBIND11_MODULE(psdparse, m) {
          },
          py::arg("index"),
          "Duplicate the layer at `index` (inserted right after it). Returns the "
-         "new layer's index. The copy shares the source's pixel bytes lazily.")
+         "new layer's index. The copy shares the source's pixel bytes lazily "
+         "but gets a fresh layer_id (max existing lyid + 1, like Photoshop).")
     .def("copy_layer_from",
          [](psd::PSDFile &self, const psd::PSDFile &src, int src_index, int dest_index) {
             int r = self.copyLayerFrom(src, src_index, dest_index);
@@ -935,7 +936,8 @@ PYBIND11_MODULE(psdparse, m) {
          "`dest_index` (default: append). Returns the new index. The copied "
          "layer references `source`'s pixel/extra bytes lazily, so `source` is "
          "kept alive until this file is garbage-collected (do not let it close "
-         "before save()). Assumes matching color mode and bit depth.")
+         "before save()). The copy gets a layer_id unique within this document. "
+         "Assumes matching color mode and bit depth.")
     .def("set_effects",
          [](psd::PSDFile &self, int index, py::dict changes) {
             editLayerDescriptor(self, index, 'lfx2', 8, changes);

{psdparse-0.8.0 → psdparse-0.8.1}/tests/test_edit.py

@@ -91,6 +91,41 @@ def test_duplicate_layer(psd_group, tmp_path):
     assert _hash(q.layer_image(6, "image")) == src_hash
 
 
+def _assert_ids_distinct(p):
+    """All positive layer IDs in the document must be unique."""
+    ids = [l.layer_id for l in p.layers if l.layer_id > 0]
+    assert len(ids) == len(set(ids)), f"duplicate layer ids: {sorted(ids)}"
+
+
+def test_duplicate_layer_assigns_fresh_id(psd_group, tmp_path):
+    # Photoshop assigns a NEW lyid when duplicating; copying it verbatim breaks
+    # downstream tools that use lyid as a persistent layer identity.
+    src_id = psd_group.layers[5].layer_id
+    new_index = psd_group.duplicate_layer(5)
+    new_id = psd_group.layers[new_index].layer_id
+    assert new_id != src_id
+    _assert_ids_distinct(psd_group)
+    q = _reload(psd_group, tmp_path)          # lyid block must be rewritten too
+    assert q.layers[new_index].layer_id == new_id
+    assert q.layers[5].layer_id == src_id
+    _assert_ids_distinct(q)
+
+
+def test_duplicate_layer_ids_distinct_psd_tools(psd_group, tmp_path):
+    import pytest
+    PSDImage = pytest.importorskip("psd_tools").PSDImage
+    psd_group.duplicate_layer(5)
+    psd_group.duplicate_layer(5)              # two copies of the same source
+    dst = tmp_path / "dup.psd"
+    assert psd_group.save(str(dst))
+    from psd_tools.constants import Tag
+    img = PSDImage.open(str(dst))
+    records = img._record.layer_and_mask_information.layer_info.layer_records
+    ids = [r.tagged_blocks.get_data(Tag.LAYER_ID, None) for r in records]
+    ids = [i for i in ids if i is not None and i > 0]
+    assert len(ids) == len(set(ids)), f"duplicate layer ids: {sorted(ids)}"
+
+
 # --- E2: move --------------------------------------------------------------
 
 def test_move_layer(psd_group, tmp_path):
@@ -116,6 +151,16 @@ def test_copy_layer_from(psd_group, psd_maskparams, tmp_path):
     assert _hash(q.layer_image(new_index, "image")) == src_hash
 
 
+def test_copy_layer_from_assigns_fresh_id(psd_group, psd_maskparams, tmp_path):
+    # The imported layer's lyid must be unique within the DESTINATION document,
+    # regardless of what id it carried in the source.
+    new_index = psd_group.copy_layer_from(psd_maskparams, 0)
+    _assert_ids_distinct(psd_group)
+    q = _reload(psd_group, tmp_path)
+    assert q.layers[new_index].layer_id == psd_group.layers[new_index].layer_id
+    _assert_ids_distinct(q)
+
+
 def test_copy_survives_source_gc(psd_group, sample_maskparams_psd, tmp_path):
     # The copied layer references the source's bytes lazily; keep_alive must
     # keep the source object alive until this file is saved even if the local