rmink 2.2.0__tar.gz → 2.2.1__tar.gz

{rmink-2.2.0 → rmink-2.2.1}/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 2.2.1 — 2026-10-24
+
+- Web UI: the shading previews are about twice as fast, so they also appear for camera photos in Safari on iPhone. If they still fail, the strip says why instead of disappearing.
+
 ## 2.2.0 — 2026-10-24
 
 - Web UI: "Send to reMarkable" uploads the notebook straight to the reMarkable Cloud, so it syncs to the tablet without USB. It uses [rmapi](https://github.com/ddvk/rmapi) (set `RMINK_RMAPI` or have `rmapi` on the PATH; the button is hidden otherwise). The first time it asks for a one-time code from my.remarkable.com; the connection is kept only in the browser. Notebooks land in *My files*, and a taken name gets `_2`, `_3` and so on.

{rmink-2.2.0 → rmink-2.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: rmink
-Version: 2.2.0
+Version: 2.2.1
 Summary: Convert images, photos, SVGs and PDFs into native, editable reMarkable ink (.rm v6 / .rmdoc)
 Project-URL: Homepage, https://github.com/thagvall/rmink
 Project-URL: Source, https://github.com/thagvall/rmink

{rmink-2.2.0 → rmink-2.2.1}/deploy/vercel/requirements.txt

@@ -1,4 +1,4 @@
 # The hosted site runs a released rmink version from PyPI.
 # Bump this after each release to update the site.
-rmink[web]==2.1.1
+rmink[web]==2.2.0
 fastapi

{rmink-2.2.0 → rmink-2.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "rmink"
-version = "2.2.0"
+version = "2.2.1"
 description = "Convert images, photos, SVGs and PDFs into native, editable reMarkable ink (.rm v6 / .rmdoc)"
 readme = "README.md"
 requires-python = ">=3.11"

{rmink-2.2.0 → rmink-2.2.1}/src/rmink/api.py

@@ -21,11 +21,14 @@ from rmink.ingest import RasterSource, Source, VectorSource, load
 from rmink.model import Document, Page, Stroke
 from rmink.options import ConvertOptions, ConvertResult, FillMode, Mode, PageStats, Shading
 from rmink.package.rmdoc import RmdocPage, UuidFactory, write_rmdoc
-from rmink.render.preview import contact_sheet, render_rm, thumbnail_png
-from rmink.writer.rm_v6 import write_page
+from rmink.render.preview import contact_sheet, render_lines, render_rm, thumbnail_png
+from rmink.writer.rm_v6 import page_lines, write_page
 
 log = logging.getLogger(__name__)
 
+# Style thumbnails extract lines at device resolution instead of 2x.
+_STYLE_OVERSAMPLE = 1.0
+
 
 @dataclass
 class Rendered:
@@ -85,7 +88,11 @@ def _raster_placement(src: RasterSource, device: DeviceProfile, opts: ConvertOpt
 
 
 def _raster_lines(
-    src: RasterSource, placement: Placement, device: DeviceProfile, opts: ConvertOptions
+    src: RasterSource,
+    placement: Placement,
+    device: DeviceProfile,
+    opts: ConvertOptions,
+    oversample: float | None = None,
 ) -> list[Stroke]:
     palette, clusters = _palette(device, opts.colors)
     # Photographed black ink reads as grey; gray is only offered when it is
@@ -94,7 +101,8 @@ def _raster_lines(
     if opts.shading != Shading.none and opts.fill == FillMode.hatch:
         # Shading draws the dark areas; even hatching would hide it.
         opts = opts.model_copy(update={"fill": FillMode.outline})
-    return extract_raster(src, placement, device, raster_palette, clusters, opts)
+    extra = {} if oversample is None else {"oversample": oversample}
+    return extract_raster(src, placement, device, raster_palette, clusters, opts, **extra)
 
 
 def source_to_page(src: Source, device: DeviceProfile, opts: ConvertOptions) -> Page:
@@ -141,14 +149,17 @@ def style_previews(
         return []
     styles = styles or list(Shading)
     placement = _raster_placement(src, device, opts)
-    plain = _raster_lines(src, placement, device, opts.model_copy(update={"shading": Shading.none}))
+    # Lines at device resolution instead of 2x: half the time, and the
+    # thumbnails are far too small to show the difference.
+    plain = _raster_lines(
+        src, placement, device, opts.model_copy(update={"shading": Shading.none}), _STYLE_OVERSAMPLE
+    )
     if opts.fill == FillMode.hatch:
         shaded = opts.model_copy(update={"shading": Shading.stipple})
-        lines = _raster_lines(src, placement, device, shaded)
+        lines = _raster_lines(src, placement, device, shaded, _STYLE_OVERSAMPLE)
     else:
         lines = plain
     tone = device_tone(src, placement, opts.shade_contrast)
-    author = UuidFactory(0)()
     out = []
     for style in styles:
         style_opts = opts.model_copy(update={"shading": style})
@@ -159,7 +170,9 @@ def style_previews(
         )
         strokes = enforce_budget(reading_order(strokes), opts.max_points, opts.simplify)
         page = Page(device.width, placement.page_height, strokes)
-        image = render_rm(write_page(page, device, author), device, page.height)
+        # Straight from the lines: writing and re-reading the .rm file took two
+        # thirds of the time, and the main preview already round-trips the writer.
+        image = render_lines(page_lines(page, device), device, page.height)
         out.append(StylePreview(style, image, len(page.strokes), page.point_count))
     return out
 

{rmink-2.2.0 → rmink-2.2.1}/src/rmink/extract/raster.py

@@ -139,10 +139,11 @@ def extract_raster(
     palette: tuple[PaletteEntry, ...],
     clusters: int | None,
     opts: ConvertOptions,
+    oversample: float = _OVERSAMPLE,
 ) -> list[Stroke]:
     rgb = src.image
-    # Resample so one mask pixel is 1/_OVERSAMPLE device pixel.
-    factor = min(placement.scale * _OVERSAMPLE, _MAX_UPSAMPLE)
+    # Resample so one mask pixel is 1/oversample device pixel.
+    factor = min(placement.scale * oversample, _MAX_UPSAMPLE)
     if abs(factor - 1) > 0.05:
         h, w = rgb.shape[:2]
         size = (max(1, round(w * factor)), max(1, round(h * factor)))

{rmink-2.2.0 → rmink-2.2.1}/src/rmink/render/preview.py

@@ -39,7 +39,12 @@ def _rgb(line: si.Line) -> tuple[int, int, int]:
 
 
 def render_rm(rm_bytes: bytes, device: DeviceProfile, height: int | None = None) -> Image.Image:
-    lines = read_lines(rm_bytes)
+    return render_lines(read_lines(rm_bytes), device, height)
+
+
+def render_lines(
+    lines: list[si.Line], device: DeviceProfile, height: int | None = None
+) -> Image.Image:
     s = device.ink_scale
     max_y = max((p.y for ln in lines for p in ln.points), default=0) / s
     h = max(height or device.height, int(max_y) + 1)

{rmink-2.2.0 → rmink-2.2.1}/src/rmink/web/static/index.html

@@ -637,8 +637,13 @@ dialog img { display: block; max-width: 96vw; max-height: 92vh; background: #fff
       }));
       markStyles();
     } catch (e) {
-      if (e.name === "AbortError") return;
-      box.hidden = true;
+      if (e.name === "AbortError" || seq !== state.styleSeq) return;
+      // Say why instead of hiding the strip; phones are slow enough to hit timeouts.
+      box.hidden = false;
+      $("#style-cards").replaceChildren(Object.assign(document.createElement("p"), {
+        className: "notice err", style: "grid-column: 1 / -1",
+        textContent: `Could not make the shading previews: ${e.message}`,
+      }));
     }
   }
 

{rmink-2.2.0 → rmink-2.2.1}/src/rmink/writer/rm_v6.py

@@ -122,6 +122,15 @@ def page_blocks(page: Page, device: DeviceProfile, author_uuid: UUID) -> Iterato
         counter += 1
 
 
+def page_lines(page: Page, device: DeviceProfile) -> list[si.Line]:
+    """The lines ``write_page`` would store, without serialising them."""
+    return [
+        b.item.value
+        for b in page_blocks(page, device, UUID(int=0))
+        if isinstance(b, SceneLineItemBlock)
+    ]
+
+
 def write_page(page: Page, device: DeviceProfile, author_uuid: UUID) -> bytes:
     buf = io.BytesIO()
     write_blocks(buf, page_blocks(page, device, author_uuid))

{rmink-2.2.0 → rmink-2.2.1}/tests/test_shading.py

@@ -11,8 +11,8 @@ from rmink.extract.shade import MAX_SHADE_STROKES, shade
 from rmink.extract.tone import tone_map
 from rmink.model import Page, Stroke
 from rmink.options import ConvertOptions, Shading
-from rmink.render.preview import read_lines
-from rmink.writer.rm_v6 import write_page
+from rmink.render.preview import read_lines, render_lines, render_rm
+from rmink.writer.rm_v6 import page_lines, write_page
 
 
 def _ramp(w=600, h=200) -> np.ndarray:
@@ -106,3 +106,14 @@ def test_style_previews(tmp_path, examples):
     assert [p.style for p in previews] == list(Shading)
     assert all(p.image.size[0] == get_device("rm2").width for p in previews)
     assert api.style_previews(examples["svg"], ConvertOptions()) == []
+
+
+def test_rendering_lines_matches_the_written_file(tmp_path):
+    # Style previews skip the .rm round trip; the picture must not change.
+    src = tmp_path / "ramp.png"
+    Image.fromarray(_ramp()).save(src)
+    device = get_device("rm2")
+    page = api.render([src], ConvertOptions(shading="pencil")).document.pages[0]
+    direct = np.asarray(render_lines(page_lines(page, device), device, page.height), float)
+    stored = render_rm(write_page(page, device, uuid.uuid4()), device, page.height)
+    assert np.abs(direct - np.asarray(stored, float)).mean() < 0.5