psdparse 0.4.0__tar.gz → 0.5.0__tar.gz

{psdparse-0.4.0 → psdparse-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: psdparse
-Version: 0.4.0
+Version: 0.5.0
 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.4.0 → psdparse-0.5.0}/docs/PYTHON_API.md

@@ -226,6 +226,34 @@ p.layer_comps   # list[dict]: [{"id","name","comment","record_visibility","recor
 p.color_table   # dict|None : {"colors":[(r,g,b,a)], "valid_count", "transparency_index"} for indexed-color PSDs
 ```
 
+### Image resources (raw)
+
+Most image resources are exposed as their raw on-disk bytes; decoding (EXIF
+tags, rendering the thumbnail, parsing the ICC profile) is left to the caller.
+
+```python
+p.image_resource_ids     # list[int]  : IDs of every resource present
+p.image_resource(id)     # bytes|None : raw bytes of the resource with that ID
+p.icc_profile            # bytes|None : ICC profile (resource 1039)
+p.exif                   # bytes|None : EXIF block (1058)
+p.xmp                    # str|None   : XMP packet (1060), UTF-8 XML
+p.thumbnail              # dict|None  : {"format","width","height","bits","resource_id","data"}
+```
+
+- **`thumbnail`** — resource 1036 (RGB) or legacy 1033 (BGR). When
+  `format == "jpeg"`, `data` is JFIF JPEG bytes ready for `PIL.Image.open`:
+
+  ```python
+  import io
+  from PIL import Image
+  th = p.thumbnail
+  if th and th["format"] == "jpeg":
+      Image.open(io.BytesIO(th["data"])).save("thumb.png")
+  ```
+
+- **`xmp`** decodes as UTF-8 `str`; if a file's packet is not valid UTF-8, read
+  the raw bytes with `p.image_resource(1060)` instead.
+
 - **`guides`** — grid spacing (in 1/32 px) and each guide's `location` (1/32 px
   from origin) and `direction` (`"vertical"` / `"horizontal"`).
 - **`slices`** — Photoshop slices (v6). Each slice has `id`, `name`, bbox

{psdparse-0.4.0 → psdparse-0.5.0}/docs/ROADMAP.md

@@ -83,6 +83,7 @@ This is mostly a constructor that fills `Data` with a minimal-but-valid skeleton
   - **Leading / faux bold-italic / underline / strikethrough / paragraph indent+spacing** — keys exist in EngineData but are default-valued in the current sample, so per-run extraction can't be verified yet; needs a sample authored with non-default values.
 - ✅ **Tier-1 reference metadata exposed to Python.** *Done 2026-08-02 (0.3.0).* Data the C++ core already parsed but Python couldn't reach is now bound: `layer.parent_index` (folder hierarchy), `layer.mask` (bbox / flags / real-mask dict), `layer.blending_ranges`, and document-level `PSDFile.guides` / `.slices` / `.layer_comps` / `.color_table`. All dict-shaped, matching the existing `layer.text` style. Validated against `config.psd` / `system.psd` (hierarchy, blend ranges, guides, slices) and a psd-tools-synthesized `masktest.psd` (mask bbox/flags cross-checked) — see `tests/test_metadata.py`.
 - ✅ **Tier-2 generic Descriptor → dict bridge.** *Done 2026-08-02 (0.4.0).* `layer.effects` (`lfx2`), `layer.fill` (`SoCo`/`GdFl`/`PtFl`), `layer.info_keys`, and a generic `layer.descriptor(key, skip)` escape hatch route previously-skipped tagged blocks through the existing complete descriptor parser (`psddesc.*`). A `Descriptor → py::dict` converter in the binding (dynamic_cast dispatch; UnitFloat→`{value,unit}`, Enumerated→`{type,value}`, nested Descriptor→dict, List→list, tdta→bytes) means no per-feature decoders were needed. Decoding is lazy: each access clones the block's reader (`clone()`+`init()`) and re-parses, so `save()` round-trips remain byte-identical. Cross-checked value-for-value against psd-tools 1.17 on `config.psd`'s PatternOverlay (opacity/scale/angle/blend/pattern-name all matched) — see `tests/test_descriptors.py`. **Deferred:** typed high-level effect/fill objects, smart-object `SoLd`/`lnkD` (embedded-file extraction), and binary adjustment layers (`levl`/`curv`) all still need work — the raw descriptor dict is the current interface.
+- ✅ **Image-resource raw bytes exposed.** *Done 2026-08-02 (0.5.0).* `PSDFile.image_resource(id)` / `.image_resource_ids` plus typed shortcuts `.icc_profile` (1039), `.exif` (1058), `.xmp` (1060, UTF-8 str) and `.thumbnail` (1036/1033 → dict with JPEG bytes + dimensions). Raw bytes only — decoding EXIF tags / rendering the thumbnail is left to the caller. EXIF and ICC bytes cross-checked byte-identical against psd-tools 1.17; thumbnail JPEG verified decodable with Pillow — see `tests/test_resources.py`. **Still raw-only / unexposed:** higher-level decode of these (parsed EXIF, ICC transform) and the structured `GlobalLayerMaskInfo`.
 - 16-bit (`Lr16`) and 32-bit-float (`Lr32`) layer data: currently captured in `layerAndMaskTrailing` for round-trip but not exposed as decoded pixels.
 - Layer mask: density / feather decoding (the `has_parameters` flag is exposed but the `MaskParameters` values are not read yet), plus re-emission for masks > 20 bytes.
 - Image resources: most are currently passed through as raw bytes. Higher-level accessors for ICC profile, EXIF, thumbnail, version info, etc. would be nice for tools.

{psdparse-0.4.0 → psdparse-0.5.0}/docs/SUPPORT.md

@@ -135,11 +135,13 @@ Photoshop の汎用ディスクリプタで格納されるブロックを dict
 | スライス (1050 v7/v8, descriptor) | ❌ | 未格納 |
 | レイヤーカンプ (1065) | ✅ | `PSDFile.layer_comps` (v0.3.0) |
 | インデックスカラーパレット (色/count/透明index) | ✅ | `PSDFile.color_table` (v0.3.0) |
-| ICC プロファイル (1039) | 📦 | 生バイト保持のみ・未公開 |
-| EXIF (1058/1059) | 📦 | 同上 |
-| XMP メタデータ (1060) | 📦 | 同上 |
-| サムネイル (1033/1036) | 📦 | 同上 |
-| バージョン情報 / アルファチャンネル名 / その他 | 📦 | 同上 |
+| ICC プロファイル (1039) | ✅ | `PSDFile.icc_profile` (生バイト, v0.5.0) |
+| EXIF (1058) | ✅ | `PSDFile.exif` (生バイト, v0.5.0) |
+| XMP メタデータ (1060) | ✅ | `PSDFile.xmp` (UTF-8 str, v0.5.0) |
+| サムネイル (1036/1033) | ✅ | `PSDFile.thumbnail` (JPEG bytes + 寸法, v0.5.0) |
+| 任意リソースの生バイト | ✅ | `PSDFile.image_resource(id)` / `image_resource_ids` (v0.5.0) |
+| 上記の内容デコード (EXIF タグ解析等) | ❌ | 生バイトを返すのみ。解析は利用側 (Pillow 等) で |
+| バージョン情報 / アルファチャンネル名 / その他 | 📦→✅ | `image_resource(id)` で生バイト取得可 |
 | Global layer mask info | 📦 | 構造体フィールドは未充填、生バイトのみ |
 
 ---
@@ -147,10 +149,12 @@ Photoshop の汎用ディスクリプタで格納されるブロックを dict
 ## まとめ (一言で)
 
 - **得意**: レイヤ列挙 + 属性 + 階層、RGB/CMYK/Gray/Indexed のピクセル取得、
-  テキストのラン単位スタイル、レイヤー効果/塗りの descriptor、主要な文書
-  メタデータ (ガイド/スライス/カンプ)、そして **byte-identical なラウンドトリップ**。
+  テキストのラン単位スタイル、レイヤー効果/塗りの descriptor、文書メタデータ
+  (ガイド/スライス/カンプ) と image resource の生バイト (ICC/EXIF/XMP/サムネイル)、
+  そして **byte-identical なラウンドトリップ**。
 - **未対応/限定的**: Lab/Duotone/Multichannel ピクセル、調整レイヤの数値
   パラメータ、ベクタパス、スマートオブジェクト実体、効果込みの再合成、
   そして編集して保存。
-- 生バイトは全ブロックが保持されているので、📦 の項目は「公開するだけ」で
-  対応できるものが多い (ROADMAP 参照)。
+- image resource の**中身の解釈** (EXIF タグ, サムネイル描画等) は行わず生バイトを
+  返すのみ。残る 📦 (global layer mask info の構造化) は「公開するだけ」で対応可
+  (ROADMAP 参照)。

{psdparse-0.4.0 → psdparse-0.5.0}/pyproject.toml

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

{psdparse-0.4.0 → psdparse-0.5.0}/python/psdparse_module.cpp

@@ -346,6 +346,82 @@ py::object layerDescriptor(const psd::LayerInfo &l, const std::string &keyStr, i
   return keyDescriptor(l, key, skip);
 }
 
+// -------------------------------------------------------------------------
+// Image resource raw-bytes access.
+//
+// Most image resources are kept as raw bytes internally (imageResourceList)
+// but were never reachable from Python. These helpers expose them: a generic
+// by-ID accessor plus typed shortcuts for the common ones (ICC / EXIF / XMP /
+// thumbnail). Decoding (parsing EXIF tags, rendering the thumbnail) is left to
+// the caller with e.g. Pillow.
+// -------------------------------------------------------------------------
+
+std::string resourceBytes(const psd::ImageResourceInfo &res) {
+  std::string buf((size_t)(res.size > 0 ? res.size : 0), '\0');
+  if (res.size > 0 && res.data) {
+    psd::IteratorBase *rd = res.data->clone();
+    rd->init();                       // rewind to the start of this resource
+    rd->getData(&buf[0], res.size);
+    delete rd;
+  }
+  return buf;
+}
+
+const psd::ImageResourceInfo *findResource(const psd::PSDFile &self, int id) {
+  for (const auto &res : self.imageResourceList)
+    if (res.id == id) return &res;
+  return nullptr;
+}
+
+py::list imageResourceIds(psd::PSDFile &self) {
+  py::list out;
+  for (const auto &res : self.imageResourceList) out.append((int)res.id);
+  return out;
+}
+
+py::object imageResource(psd::PSDFile &self, int id) {
+  const psd::ImageResourceInfo *res = findResource(self, id);
+  return res ? py::object(py::bytes(resourceBytes(*res))) : py::none();
+}
+
+py::object iccProfile(psd::PSDFile &self) { return imageResource(self, 1039); }
+py::object exifData(psd::PSDFile &self)   { return imageResource(self, 1058); }
+
+// XMP packet (resource 1060) is UTF-8 XML. Returned as str; use
+// image_resource(1060) for the raw bytes if the packet is not valid UTF-8.
+py::object xmpMetadata(psd::PSDFile &self) {
+  const psd::ImageResourceInfo *res = findResource(self, 1060);
+  if (!res) return py::none();
+  return py::str(resourceBytes(*res));
+}
+
+// Embedded thumbnail (resource 1036 = RGB / legacy 1033 = BGR). Header is 28
+// bytes; for format==1 the payload is a JFIF JPEG. Returns a dict with the
+// header fields and the raw payload, or None.
+py::object thumbnail(psd::PSDFile &self) {
+  const psd::ImageResourceInfo *res = findResource(self, 1036);
+  if (!res) res = findResource(self, 1033);
+  if (!res) return py::none();
+  std::string raw = resourceBytes(*res);
+  if (raw.size() < 28) return py::none();
+  auto be32 = [&](size_t o) {
+    return (uint32_t)(((uint8_t)raw[o] << 24) | ((uint8_t)raw[o+1] << 16) |
+                      ((uint8_t)raw[o+2] << 8) | (uint8_t)raw[o+3]);
+  };
+  auto be16 = [&](size_t o) {
+    return (uint16_t)(((uint8_t)raw[o] << 8) | (uint8_t)raw[o+1]);
+  };
+  py::dict d;
+  uint32_t fmt = be32(0);
+  d["format"]      = (fmt == 1) ? "jpeg" : "raw";
+  d["width"]       = be32(4);
+  d["height"]      = be32(8);
+  d["bits"]        = be16(24);
+  d["resource_id"] = (int)res->id;   // 1036 = RGB order, 1033 = BGR order
+  d["data"]        = py::bytes(raw.data() + 28, raw.size() - 28);
+  return std::move(d);
+}
+
 py::bytes layerImage(psd::PSDFile &self, int index, const std::string &mode) {
   if (!self.isLoaded) throw std::runtime_error("PSD not loaded");
   if (index < 0 || index >= (int)self.layerList.size())
@@ -537,7 +613,22 @@ PYBIND11_MODULE(psdparse, m) {
          "(id, name, comment, record_*). Empty list when there are none.")
     .def_property_readonly("color_table", &psdColorTable,
          "Indexed-color palette as a dict (colors[], valid_count, "
-         "transparency_index), or None for non-indexed PSDs.");
+         "transparency_index), or None for non-indexed PSDs.")
+    .def_property_readonly("image_resource_ids", &imageResourceIds,
+         "List of the integer IDs of every image resource present.")
+    .def("image_resource", &imageResource, py::arg("id"),
+         "Raw bytes of the image resource with the given integer ID, or None.")
+    .def_property_readonly("icc_profile", &iccProfile,
+         "ICC profile (resource 1039) as raw bytes, or None.")
+    .def_property_readonly("exif", &exifData,
+         "EXIF block (resource 1058) as raw bytes, or None.")
+    .def_property_readonly("xmp", &xmpMetadata,
+         "XMP metadata (resource 1060) as a UTF-8 str, or None. Use "
+         "image_resource(1060) for raw bytes if not valid UTF-8.")
+    .def_property_readonly("thumbnail", &thumbnail,
+         "Embedded thumbnail (resource 1036/1033) as a dict "
+         "(format, width, height, bits, resource_id, data), or None. "
+         "For format=='jpeg', data is JFIF JPEG bytes.");
 
   // Enum-like ints exposed as module attributes for convenience
   m.attr("LAYER_TYPE_NORMAL") = (int)psd::LAYER_TYPE_NORMAL;

psdparse-0.5.0/tests/test_resources.py

@@ -0,0 +1,69 @@
+"""Tests for image-resource raw-bytes access (0.5.0):
+
+PSDFile.image_resource_ids / image_resource(id) and the typed shortcuts
+icc_profile / exif / xmp / thumbnail. EXIF and ICC bytes here were verified
+byte-identical against psd-tools 1.17.
+"""
+import psdparse
+import pytest
+
+
+def test_resource_ids_are_ints(psd_group):
+    ids = psd_group.image_resource_ids
+    assert isinstance(ids, list)
+    assert all(isinstance(i, int) for i in ids)
+    assert len(ids) > 0
+
+
+def test_generic_matches_typed(psd_group):
+    # image_resource(1058) is the same bytes as the exif shortcut.
+    assert psd_group.image_resource(1058) == psd_group.exif
+
+
+def test_absent_resource_is_none(psd_group):
+    # 9999 is not a real Photoshop resource id.
+    assert psd_group.image_resource(9999) is None
+
+
+def test_exif_present(psd_group):
+    exif = psd_group.exif
+    if exif is None:
+        pytest.skip("sample has no EXIF resource")
+    assert isinstance(exif, bytes) and len(exif) > 0
+
+
+def test_xmp_is_xml(psd_group):
+    xmp = psd_group.xmp
+    if xmp is None:
+        pytest.skip("sample has no XMP resource")
+    assert isinstance(xmp, str)
+    assert "xpacket" in xmp or "xmpmeta" in xmp
+
+
+def test_icc_profile(psd_text):
+    # fontsample.psd carries an ICC profile.
+    icc = psd_text.icc_profile
+    if icc is None:
+        pytest.skip("sample has no ICC profile")
+    assert isinstance(icc, bytes) and len(icc) > 0
+
+
+def test_thumbnail_header(psd_group):
+    th = psd_group.thumbnail
+    if th is None:
+        pytest.skip("sample has no thumbnail")
+    assert th["width"] > 0 and th["height"] > 0
+    assert th["format"] in ("jpeg", "raw")
+    assert isinstance(th["data"], bytes)
+    if th["format"] == "jpeg":
+        assert th["data"][:2] == b"\xff\xd8"  # JFIF/JPEG SOI marker
+
+
+def test_thumbnail_decodes(psd_group):
+    Image = pytest.importorskip("PIL.Image")
+    th = psd_group.thumbnail
+    if th is None or th["format"] != "jpeg":
+        pytest.skip("sample has no JPEG thumbnail")
+    import io
+    img = Image.open(io.BytesIO(th["data"]))
+    assert (img.width, img.height) == (th["width"], th["height"])