fix: align Python translation with upstream prosemirror-model 1.18.1

Fixes translation issues up to 1.18.1, updates typing to use ty, and
fixes typos.

Bug fixes:
- find_diff_start crashed on text nodes of different lengths (used
  zip(strict=True) instead of min-length loop)
- find_diff_start returned wrong result for position 0 (falsy check
  instead of `is not None`)
- Slice.max_open had inverted `isolating` check, traversing into
  isolating nodes when it shouldn't

Identity-vs-name comparison fixes (8 occurrences):
- content.py: match_type(), compatible(), find_wrapping() used string
  name comparison instead of identity
- mark.py: eq() used name comparison instead of identity
- node.py: has_markup() used name comparison instead of identity
- schema.py: MarkType.excludes() used name comparison instead of
  identity

Other translation fixes:
- mark.py: to_json() no longer includes empty attrs in output
- mark.py: remove_from_set() returns original set when mark not found
- mark.py: eq() uses `is` instead of `==` for self-check
- fragment.py: nodes_between uses direct content.size access
- fragment.py: child() raises proper bounds error message
- node.py: to_json() removed unnecessary deepcopy
- content.py: null_from sorted descending to match upstream

Typo fixes:
- content.py: "missing closing patren" -> "Missing closing paren"
- schema.py: "unknow mark type" -> "Unknown mark type"

Tooling:
- Replace mypy/pyright with ty for type checking
- Loosen dev dependency version constraints
- Remove dependabot.yml
- Update test expectations and README for mark serialization changes

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: sciyoshi

.github/dependabot.yml

@@ -66,7 +66,7 @@ assert [step.to_json() for step in tr.steps] == [{
     'to': 5
 }, {
     'stepType': 'addMark',
-    'mark': {'type': 'strong', 'attrs': {}},
+    'mark': {'type': 'strong'},
     'from': 1,
     'to': 4
 }]
@@ -78,7 +78,7 @@ assert tr.doc.to_json() == {
         'type': 'paragraph',
         'content': [{
             'type': 'text',
-            'marks': [{'type': 'strong', 'attrs': {}}],
+            'marks': [{'type': 'strong'}],
             'text': 'Heo'
         }, {
             'type': 'text',
@@ -87,3 +87,8 @@ assert tr.doc.to_json() == {
     }]
 }
 ```
+
+## AI Disclosure
+
+The initial version of this translation was written manually in 2019. AI is now
+used to help keep this translation up-to-date with upstream changes.

README.md

@@ -1,6 +1,9 @@
+from typing import Any
+
 from prosemirror.model import Node, Schema
+from prosemirror.model.schema import SchemaSpec
 
-basic_spec = {
+basic_spec: SchemaSpec[Any, Any] = {
     "nodes": {
         "doc": {"content": "block+"},
         "paragraph": {

example.py

@@ -69,7 +69,7 @@ def parse(cls, string: str, node_types: dict[str, "NodeType"]) -> "ContentMatch"
 
     def match_type(self, type: "NodeType") -> Optional["ContentMatch"]:
         for next in self.next:
-            if next.type.name == type.name:
+            if next.type == type:
                 return next.next
         return None
 
@@ -103,7 +103,7 @@ def default_type(self) -> Optional["NodeType"]:
     def compatible(self, other: "ContentMatch") -> bool:
         for i in self.next:
             for j in other.next:
-                if i.type.name == j.type.name:
+                if i.type == j.type:
                     return True
         return False
 
@@ -136,7 +136,7 @@ def search(match: ContentMatch, types: list["NodeType"]) -> Fragment | None:
 
     def find_wrapping(self, target: "NodeType") -> list["NodeType"] | None:
         for entry in self.wrap_cache:
-            if entry.target.name == target.name:
+            if entry.target == target:
                 return entry.computed
         computed = self.compute_wrapping(target)
         self.wrap_cache.append(WrapCacheEntry(target, computed))
@@ -365,7 +365,7 @@ def parse_expr_atom(
     if stream.eat("("):
         expr = parse_expr(stream)
         if not stream.eat(")"):
-            stream.err("missing closing patren")
+            stream.err("Missing closing paren")
         return expr
     elif not re.match(r"\W", cast(str, stream.next())):
 
@@ -491,7 +491,7 @@ def scan(n: int) -> None:
                 scan(cast(int, to))
 
     scan(node)
-    return sorted(result)
+    return sorted(result, key=cmp_to_key(cmp))
 
 
 class DFAState(NamedTuple):

prosemirror/model/content.py

@@ -1,11 +1,8 @@
-from typing import TYPE_CHECKING, TypedDict
-
-from prosemirror.utils import text_length
-
-from . import node as pm_node
+from typing import TYPE_CHECKING, TypedDict, cast
 
 if TYPE_CHECKING:
     from prosemirror.model.fragment import Fragment
+    from prosemirror.model.node import TextNode
 
 
 class Diff(TypedDict):
@@ -16,39 +13,27 @@ class Diff(TypedDict):
 def find_diff_start(a: "Fragment", b: "Fragment", pos: int) -> int | None:
     i = 0
     while True:
-        if a.child_count == i or b.child_count == i:
+        if i == a.child_count or i == b.child_count:
             return None if a.child_count == b.child_count else pos
         child_a, child_b = a.child(i), b.child(i)
         if child_a == child_b:
             pos += child_a.node_size
+            i += 1
             continue
         if not child_a.same_markup(child_b):
             return pos
         if child_a.is_text:
-            assert isinstance(child_a, pm_node.TextNode)
-            assert isinstance(child_b, pm_node.TextNode)
-            if child_a.text != child_b.text:
-                if child_b.text.startswith(child_a.text):
-                    return pos + text_length(child_a.text)
-                if child_a.text.startswith(child_b.text):
-                    return pos + text_length(child_b.text)
-                next_index = next(
-                    (
-                        index_a
-                        for ((index_a, char_a), (_, char_b)) in zip(
-                            enumerate(child_a.text),
-                            enumerate(child_b.text),
-                            strict=True,
-                        )
-                        if char_a != char_b
-                    ),
-                    None,
-                )
-                if next_index is not None:
-                    return pos + next_index
+            text_a = cast("TextNode", child_a).text
+            text_b = cast("TextNode", child_b).text
+            if text_a != text_b:
+                j = 0
+                while j < len(text_a) and j < len(text_b) and text_a[j] == text_b[j]:
+                    j += 1
+                    pos += 1
+                return pos
         if child_a.content.size or child_b.content.size:
             inner = find_diff_start(child_a.content, child_b.content, pos + 1)
-            if inner:
+            if inner is not None:
                 return inner
         pos += child_a.node_size
         i += 1
@@ -58,10 +43,7 @@ def find_diff_end(a: "Fragment", b: "Fragment", pos_a: int, pos_b: int) -> Diff
     i_a, i_b = a.child_count, b.child_count
     while True:
         if i_a == 0 or i_b == 0:
-            if i_a == i_b:
-                return None
-            else:
-                return {"a": pos_a, "b": pos_b}
+            return None if i_a == i_b else {"a": pos_a, "b": pos_b}
         i_a -= 1
         i_b -= 1
         child_a, child_b = a.child(i_a), b.child(i_b)
@@ -75,17 +57,14 @@ def find_diff_end(a: "Fragment", b: "Fragment", pos_a: int, pos_b: int) -> Diff
             return {"a": pos_a, "b": pos_b}
 
         if child_a.is_text:
-            assert isinstance(child_a, pm_node.TextNode)
-            assert isinstance(child_b, pm_node.TextNode)
-            if child_a.text != child_b.text:
-                same, min_size = (
-                    0,
-                    min(text_length(child_a.text), text_length(child_b.text)),
-                )
+            text_a = cast("TextNode", child_a).text
+            text_b = cast("TextNode", child_b).text
+            if text_a != text_b:
+                same = 0
+                min_size = min(len(text_a), len(text_b))
                 while (
                     same < min_size
-                    and child_a.text[text_length(child_a.text) - same - 1]
-                    == child_b.text[text_length(child_b.text) - same - 1]
+                    and text_a[len(text_a) - same - 1] == text_b[len(text_b) - same - 1]
                 ):
                     same += 1
                     pos_a -= 1

prosemirror/model/diff.py

@@ -1,4 +1,4 @@
-from collections.abc import Callable, Iterable, Sequence
+from collections.abc import Callable, Sequence
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -46,7 +46,7 @@ def nodes_between(
             if (
                 end > from_
                 and f(child, node_start + pos, parent, i) is not False
-                and getattr(child.content, "size", None)
+                and child.content.size
             ):
                 start = pos + 1
                 child.nodes_between(
@@ -192,7 +192,11 @@ def child_count(self) -> int:
         return len(self.content)
 
     def child(self, index: int) -> "Node":
-        return self.content[index]
+        found = self.content[index] if index < len(self.content) else None
+        if not found:
+            msg = f"Index {index} out of range for {self}"
+            raise IndexError(msg)
+        return found
 
     def maybe_child(self, index: int) -> Optional["Node"]:
         try:
@@ -297,8 +301,8 @@ def from_(
             return cls.empty
         if isinstance(nodes, Fragment):
             return nodes
-        if isinstance(nodes, Iterable):
-            return cls.from_array(list(nodes))
+        if isinstance(nodes, Sequence):
+            return cls.from_array(cast(list["Node"], list(nodes)))
         if hasattr(nodes, "attrs"):
             return cls([nodes], nodes.node_size)
         msg = f"cannot convert {nodes!r} to a fragment"

prosemirror/model/fragment.py

@@ -721,7 +721,8 @@ def read_styles(self, styles: list[str]) -> tuple[list[Mark], list[Mark]] | None
                             remove = m.add_to_set(remove)
                 else:
                     add = (
-                        self.parser.schema.marks[cast(str, rule.mark)]
+                        self.parser.schema
+                        .marks[cast(str, rule.mark)]
                         .create(rule.attrs)
                         .add_to_set(add)
                     )
@@ -1042,7 +1043,8 @@ def textblock_from_context(self) -> NodeType | None:
             d = context.depth
             while d >= 0:
                 default = (
-                    context.node(d)
+                    context
+                    .node(d)
                     .content_match_at(context.index_after(d))
                     .default_type
                 )
@@ -1230,7 +1232,7 @@ def get_node_type(element: DOMNode) -> int:
 
 
 def from_html(schema: Schema[Any, Any], html: str) -> JSONDict:
-    fragment = lxml.html.fragment_fromstring(html, create_parent="document-fragment")  # type: ignore[arg-type]
+    fragment = lxml.html.fragment_fromstring(html, create_parent="document-fragment")
 
     prose_doc = DOMParser.from_schema(schema).parse(fragment)
 

prosemirror/model/from_dom.py

@@ -1,4 +1,3 @@
-import copy
 from typing import TYPE_CHECKING, Any, Final, Union, cast
 
 from prosemirror.utils import Attrs, JSONDict
@@ -41,18 +40,24 @@ def add_to_set(self, set: list["Mark"]) -> list["Mark"]:
         return copy
 
     def remove_from_set(self, set: list["Mark"]) -> list["Mark"]:
-        return [item for item in set if not item.eq(self)]
+        for i in range(len(set)):
+            if self.eq(set[i]):
+                return set[:i] + set[i + 1 :]
+        return set
 
     def is_in_set(self, set: list["Mark"]) -> bool:
         return any(item.eq(self) for item in set)
 
     def eq(self, other: "Mark") -> bool:
-        if self == other:
+        if self is other:
             return True
-        return self.type.name == other.type.name and self.attrs == other.attrs
+        return self.type == other.type and self.attrs == other.attrs
 
     def to_json(self) -> JSONDict:
-        return {"type": self.type.name, "attrs": copy.deepcopy(self.attrs)}
+        obj: JSONDict = {"type": self.type.name}
+        if self.attrs:
+            obj = {**obj, "attrs": self.attrs}
+        return obj
 
     @classmethod
     def from_json(

prosemirror/model/mark.py

@@ -1,4 +1,3 @@
-import copy
 from collections.abc import Callable
 from typing import TYPE_CHECKING, Any, Optional, TypedDict, TypeGuard, Union, cast
 
@@ -110,9 +109,9 @@ def has_markup(
         marks: list[Mark] | None = None,
     ) -> bool:
         return (
-            self.type.name == type.name
-            and (compare_deep(self.attrs, attrs or type.default_attrs or empty_attrs))
-            and (Mark.same_set(self.marks, marks or Mark.none))
+            self.type == type
+            and compare_deep(self.attrs, attrs or type.default_attrs or empty_attrs)
+            and Mark.same_set(self.marks, marks or Mark.none)
         )
 
     def copy(self, content: Fragment | None = None) -> "Node":
@@ -323,20 +322,11 @@ def iteratee(node: "Node", offset: int, index: int) -> None:
     def to_json(self) -> JSONDict:
         obj: JSONDict = {"type": self.type.name}
         if self.attrs:
-            obj = {
-                **obj,
-                "attrs": copy.deepcopy(self.attrs),
-            }
-        if getattr(self.content, "size", None):
-            obj = {
-                **obj,
-                "content": self.content.to_json(),
-            }
+            obj = {**obj, "attrs": self.attrs}
+        if self.content.size:
+            obj = {**obj, "content": self.content.to_json()}
         if len(self.marks):
-            obj = {
-                **obj,
-                "marks": [n.to_json() for n in self.marks],
-            }
+            obj = {**obj, "marks": [n.to_json() for n in self.marks]}
         return obj
 
     @classmethod

prosemirror/model/node.py

@@ -130,11 +130,15 @@ def max_open(cls, fragment: Fragment, open_isolating: bool = True) -> "Slice":
         open_start = 0
         open_end = 0
         n = fragment.first_child
-        while n and not n.is_leaf and (open_isolating or n.type.spec.get("isolating")):
+        while (
+            n and not n.is_leaf and (open_isolating or not n.type.spec.get("isolating"))
+        ):
             open_start += 1
             n = n.first_child
         n = fragment.last_child
-        while n and not n.is_leaf and (open_isolating or n.type.spec.get("isolating")):
+        while (
+            n and not n.is_leaf and (open_isolating or not n.type.spec.get("isolating"))
+        ):
             open_end += 1
             n = n.last_child
         return cls(fragment, open_start, open_end)
@@ -176,7 +180,8 @@ def replace_outer(
         content = parent.content
         return close(
             parent,
-            content.cut(0, from_.parent_offset)
+            content
+            .cut(0, from_.parent_offset)
             .append(slice.content)
             .append(content.cut(to.parent_offset)),
         )