pycrdt 0.12.35__cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl → 0.12.45__cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl

pycrdt/__init__.py

@@ -1,3 +1,7 @@
+from pkgutil import extend_path
+
+__path__ = extend_path(__path__, __name__)
+
 from ._array import Array as Array
 from ._array import ArrayEvent as ArrayEvent
 from ._array import TypedArray as TypedArray
@@ -10,6 +14,7 @@ from ._map import MapEvent as MapEvent
 from ._map import TypedMap as TypedMap
 from ._provider import Channel as Channel
 from ._provider import Provider as Provider
+from ._pycrdt import DeleteSet as DeleteSet
 from ._pycrdt import StackItem as StackItem
 from ._pycrdt import SubdocsEvent as SubdocsEvent
 from ._pycrdt import Subscription as Subscription

pycrdt/_base.py

@@ -4,6 +4,7 @@ import threading
 from abc import ABC, abstractmethod
 from functools import lru_cache, partial
 from inspect import signature
+from types import UnionType
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -12,12 +13,15 @@ from typing import (
     Type,
     Union,
     cast,
+    get_args,
+    get_origin,
     get_type_hints,
     overload,
 )
 
 import anyio
 from anyio import BrokenResourceError, create_memory_object_stream
+from anyio.abc import TaskGroup
 from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
 
 from ._pycrdt import Doc as _Doc
@@ -43,12 +47,14 @@ class BaseDoc:
     _doc: _Doc
     _twin_doc: BaseDoc | None
     _txn: Transaction | None
+    _exceptions: list[Exception]
     _txn_lock: threading.Lock
     _txn_async_lock: anyio.Lock
     _allow_multithreading: bool
     _Model: Any
     _subscriptions: list[Subscription]
     _origins: dict[int, Any]
+    _task_group: TaskGroup | None
 
     def __init__(
         self,
@@ -65,12 +71,14 @@ class BaseDoc:
             doc = _Doc(client_id, skip_gc)
         self._doc = doc
         self._txn = None
+        self._exceptions = []
         self._txn_lock = threading.Lock()
         self._txn_async_lock = anyio.Lock()
         self._Model = Model
         self._subscriptions = []
         self._origins = {}
         self._allow_multithreading = allow_multithreading
+        self._task_group = None
 
 
 class BaseType(ABC):
@@ -296,7 +304,10 @@ def observe_callback(
     _event = event_types[type(event)](event, doc)
     with doc._read_transaction(event.transaction) as txn:
         params = (_event, txn)
-        callback(*params[:param_nb])  # type: ignore[arg-type]
+        try:
+            callback(*params[:param_nb])  # type: ignore[arg-type]
+        except Exception as exc:
+            doc._exceptions.append(exc)
 
 
 def observe_deep_callback(
@@ -309,7 +320,10 @@ def observe_deep_callback(
         events[idx] = event_types[type(event)](event, doc)
     with doc._read_transaction(event.transaction) as txn:
         params = (events, txn)
-        callback(*params[:param_nb])  # type: ignore[arg-type]
+        try:
+            callback(*params[:param_nb])  # type: ignore[arg-type]
+        except Exception as exc:
+            doc._exceptions.append(exc)
 
 
 class BaseEvent:
@@ -385,10 +399,12 @@ class Typed:
             if key not in annotations:
                 raise AttributeError(f'"{type(self).mro()[0]}" has no attribute "{key}"')
             expected_type = annotations[key]
-            if hasattr(expected_type, "__origin__"):
-                expected_type = expected_type.__origin__
-            if hasattr(expected_type, "__args__"):
-                expected_types = expected_type.__args__
+            origin = get_origin(expected_type)
+            if origin in (Union, UnionType):
+                expected_types = get_args(expected_type)
+            elif origin is not None:
+                expected_type = origin
+                expected_types = (expected_type,)
             else:
                 expected_types = (expected_type,)
             if type(value) not in expected_types:

pycrdt/_doc.py

@@ -1,7 +1,20 @@
 from __future__ import annotations
 
 from functools import partial
-from typing import Any, Callable, Generic, Iterable, Literal, Type, TypeVar, Union, cast, overload
+from inspect import iscoroutinefunction
+from typing import (
+    Any,
+    Awaitable,
+    Callable,
+    Generic,
+    Iterable,
+    Literal,
+    Type,
+    TypeVar,
+    Union,
+    cast,
+    overload,
+)
 
 from anyio import BrokenResourceError, create_memory_object_stream
 from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
@@ -14,6 +27,9 @@ from ._snapshot import Snapshot
 from ._transaction import NewTransaction, ReadTransaction, Transaction
 
 T = TypeVar("T", bound=BaseType)
+TransactionOrSubdocsEvent = TypeVar(
+    "TransactionOrSubdocsEvent", bound=TransactionEvent | SubdocsEvent
+)
 
 
 class Doc(BaseDoc, Generic[T]):
@@ -45,7 +61,11 @@ class Doc(BaseDoc, Generic[T]):
             allow_multithreading: Whether to allow the document to be used in different threads.
         """
         super().__init__(
-            client_id=client_id, skip_gc=skip_gc, doc=doc, Model=Model, allow_multithreading=allow_multithreading
+            client_id=client_id,
+            skip_gc=skip_gc,
+            doc=doc,
+            Model=Model,
+            allow_multithreading=allow_multithreading,
         )
         for k, v in init.items():
             self[k] = v
@@ -144,7 +164,9 @@ class Doc(BaseDoc, Generic[T]):
         Returns:
             The current document state.
         """
-        return self._doc.get_state()
+        with self.transaction() as txn:
+            assert txn._txn is not None
+            return self._doc.get_state(txn._txn)
 
     def get_update(self, state: bytes | None = None) -> bytes:
         """
@@ -156,7 +178,9 @@ class Doc(BaseDoc, Generic[T]):
         """
         if state is None:
             state = b"\x00"
-        return self._doc.get_update(state)
+        with self.transaction() as txn:
+            assert txn._txn is not None
+            return self._doc.get_update(txn._txn, state)
 
     def apply_update(self, update: bytes) -> None:
         """
@@ -284,21 +308,44 @@ class Doc(BaseDoc, Generic[T]):
                 for key, val in self._doc.roots(txn._txn).items()
             }
 
-    def observe(self, callback: Callable[[TransactionEvent], None]) -> Subscription:
+    def observe(
+        self,
+        callback: Callable[[TransactionEvent], None]
+        | Callable[[TransactionEvent], Awaitable[None]],
+    ) -> Subscription:
         """
         Subscribes a callback to be called with the document change event.
 
         Args:
             callback: The callback to call with the [TransactionEvent][pycrdt.TransactionEvent].
+                If the callback is async, async transactions must be used.
 
         Returns:
             The subscription that can be used to [unobserve()][pycrdt.Doc.unobserve].
         """
-        subscription = self._doc.observe(callback)
+        if iscoroutinefunction(callback):
+            cb = self._async_callback_to_sync(callback)
+        else:
+            cb = partial(observe_callback, cast(Callable[[TransactionEvent], None], callback), self)
+        subscription = self._doc.observe(cb)
         self._subscriptions.append(subscription)
         return subscription
 
-    def observe_subdocs(self, callback: Callable[[SubdocsEvent], None]) -> Subscription:
+    def _async_callback_to_sync(
+        self,
+        async_callback: Callable[[TransactionOrSubdocsEvent], Awaitable[None]],
+    ) -> Callable[[TransactionOrSubdocsEvent], None]:
+        def callback(event: TransactionOrSubdocsEvent) -> None:
+            if self._task_group is None:
+                raise RuntimeError("Async callback in non-async transaction")
+            self._task_group.start_soon(async_callback, event)
+
+        return callback
+
+    def observe_subdocs(
+        self,
+        callback: Callable[[SubdocsEvent], None] | Callable[[SubdocsEvent], Awaitable[None]],
+    ) -> Subscription:
         """
         Subscribes a callback to be called with the document subdoc change event.
 
@@ -308,7 +355,11 @@ class Doc(BaseDoc, Generic[T]):
         Returns:
             The subscription that can be used to [unobserve()][pycrdt.Doc.unobserve].
         """
-        subscription = self._doc.observe_subdocs(callback)
+        if iscoroutinefunction(callback):
+            cb = self._async_callback_to_sync(callback)
+        else:
+            cb = partial(observe_callback, cast(Callable[[SubdocsEvent], None], callback), self)
+        subscription = self._doc.observe_subdocs(cb)
         self._subscriptions.append(subscription)
         return subscription
 
@@ -327,6 +378,7 @@ class Doc(BaseDoc, Generic[T]):
         self,
         subdocs: Literal[False] = False,
         max_buffer_size: float = float("inf"),
+        async_transactions: bool = False,
     ) -> MemoryObjectReceiveStream[TransactionEvent]: ...
 
     @overload
@@ -334,12 +386,14 @@ class Doc(BaseDoc, Generic[T]):
         self,
         subdocs: Literal[True] = True,
         max_buffer_size: float = float("inf"),
+        async_transactions: bool = False,
     ) -> MemoryObjectReceiveStream[list[SubdocsEvent]]: ...
 
     def events(
         self,
         subdocs: bool = False,
         max_buffer_size: float = float("inf"),
+        async_transactions: bool = False,
     ):
         """
         Allows to asynchronously iterate over the document events, without using a callback.
@@ -360,13 +414,21 @@ class Doc(BaseDoc, Generic[T]):
             subdocs: Whether to iterate over the [SubdocsEvent][pycrdt.SubdocsEvent] events
                 (default is [TransactionEvent][pycrdt.TransactionEvent]).
             max_buffer_size: Maximum number of events that can be buffered.
+            async_transactions: Whether async transactions are used for this document,
+                in which case iterating over the events can put back-pressure on the
+                transactions (don't use an infinite `max_buffer_size` in this case).
 
         Returns:
             An async iterator over the document events.
         """
         observe = self.observe_subdocs if subdocs else self.observe
         if not self._send_streams[subdocs]:
-            self._event_subscription[subdocs] = observe(partial(self._send_event, subdocs))
+            if async_transactions:
+                self._event_subscription[subdocs] = observe(
+                    partial(self._async_send_event, subdocs)
+                )
+            else:
+                self._event_subscription[subdocs] = observe(partial(self._send_event, subdocs))
         send_stream, receive_stream = create_memory_object_stream[
             Union[TransactionEvent, SubdocsEvent]
         ](max_buffer_size=max_buffer_size)
@@ -387,6 +449,20 @@ class Doc(BaseDoc, Generic[T]):
         if not send_streams:
             self.unobserve(self._event_subscription[subdocs])
 
+    async def _async_send_event(self, subdocs: bool, event: TransactionEvent | SubdocsEvent):
+        to_remove: list[MemoryObjectSendStream[TransactionEvent | SubdocsEvent]] = []
+        send_streams = self._send_streams[subdocs]
+        for send_stream in send_streams:
+            try:
+                await send_stream.send(event)
+            except BrokenResourceError:
+                to_remove.append(send_stream)
+        for send_stream in to_remove:
+            send_stream.close()
+            send_streams.remove(send_stream)
+        if not send_streams:
+            self.unobserve(self._event_subscription[subdocs])
+
 
 class TypedDoc(Typed):
     """
@@ -427,4 +503,15 @@ class TypedDoc(Typed):
             doc[name] = root_type
 
 
+def observe_callback(
+    callback: Callable[[TransactionEvent], None] | Callable[[SubdocsEvent], None],
+    doc: Doc,
+    event: Any,
+) -> None:
+    try:
+        callback(event)
+    except Exception as exc:
+        doc._exceptions.append(exc)
+
+
 base_types[_Doc] = Doc

pycrdt/_provider.py

@@ -141,10 +141,8 @@ class Provider:
         return self
 
     async def __aexit__(self, exc_type, exc_value, exc_tb):
-        try:
-            await self.stop()
-        finally:
-            return await self._exit_stack.__aexit__(exc_type, exc_value, exc_tb)
+        await self.stop()
+        return await self._exit_stack.__aexit__(exc_type, exc_value, exc_tb)
 
     @asynccontextmanager
     async def _get_or_create_task_group(self) -> AsyncIterator[TaskGroup]:

pycrdt/_pycrdt.pyi

@@ -1,4 +1,4 @@
-from typing import Any, Callable, Iterator
+from typing import Any, Callable, Generic, Iterator, TypeVar
 
 class Snapshot:
     """A snapshot of a document's state at a given point in time."""
@@ -49,10 +49,10 @@ class Doc:
     def get_or_insert_xml_fragment(self, txn: Transaction, name: str) -> XmlFragment:
         """Create an XML fragment root type on this document, or get an existing one."""
 
-    def get_state(self) -> bytes:
+    def get_state(self, txn: Transaction) -> bytes:
         """Get the current document state."""
 
-    def get_update(self, state: bytes) -> bytes:
+    def get_update(self, txn: Transaction, state: bytes) -> bytes:
         """Get the update from the given state to the current state."""
 
     def apply_update(self, txn: Transaction, update: bytes) -> None:
@@ -363,7 +363,14 @@ class XmlText:
 class UndoManager:
     """Undo manager."""
 
-    def __init__(self, doc: Doc, capture_timeout_millis, timestamp: Callable[[], int]) -> None:
+    def __init__(
+        self,
+        doc: Doc,
+        capture_timeout_millis: int,
+        timestamp: Callable[[], int],
+        undo_stack: list[StackItem] | None = None,
+        redo_stack: list[StackItem] | None = None,
+    ) -> None:
         """Creates an undo manager."""
 
     def expand_scope(self, scope: Text | Array | Map) -> None:
@@ -396,11 +403,65 @@ class UndoManager:
     def redo_stack(self) -> list[StackItem]:
         """Returns the undo manager's redo stack."""
 
-class StackItem:
+class DeleteSet:
+    """A set of deletions in a CRDT document."""
+
+    def __init__(self) -> None:
+        """Create a new empty DeleteSet."""
+
+    def encode(self) -> bytes:
+        """Encode the DeleteSet to bytes."""
+
+    @staticmethod
+    def decode(data: bytes) -> DeleteSet:
+        """Decode a DeleteSet from bytes."""
+
+MetaT = TypeVar("MetaT")
+
+class StackItem(Generic[MetaT]):
     """A unit of work for the [UndoManager][pycrdt.UndoManager], consisting of
     compressed information about all updates and deletions tracked by it.
     """
 
+    def __init__(
+        self, deletions: DeleteSet, insertions: DeleteSet, meta: MetaT | None = None
+    ) -> None:
+        """Create a new StackItem.
+
+        Args:
+            deletions: The DeleteSet of deletions.
+            insertions: The DeleteSet of insertions.
+            meta: Optional metadata (can be any Python object).
+        """
+
+    @property
+    def deletions(self) -> DeleteSet:
+        """Get the deletions DeleteSet."""
+
+    @property
+    def insertions(self) -> DeleteSet:
+        """Get the insertions DeleteSet."""
+
+    @property
+    def meta(self) -> MetaT | None:
+        """Custom metadata. Can be any Python object."""
+
+    @staticmethod
+    def merge(
+        a: "StackItem[MetaT]",
+        b: "StackItem[MetaT]",
+        merge_meta: Callable[[MetaT | None, MetaT | None], Any] | None = None,
+    ) -> "StackItem[Any]":
+        """Merge two StackItems into one containing the union of their deletions and insertions.
+
+        Args:
+            a: First StackItem to merge.
+            b: Second StackItem to merge.
+            merge_meta: Optional function to handle metadata conflicts.
+                Takes (meta_a, meta_b) and returns the merged metadata.
+                If None, keeps the first item's metadata.
+        """
+
 class StickyIndex:
     def get_offset(self, txn: Transaction) -> int: ...
     def encode(self) -> bytes: ...

pycrdt/_transaction.py

@@ -1,13 +1,17 @@
 from __future__ import annotations
 
+import sys
 from functools import partial
 from types import TracebackType
 from typing import TYPE_CHECKING, Any
 
-from anyio import to_thread
+from anyio import create_task_group, to_thread
 
 from ._pycrdt import Transaction as _Transaction
 
+if sys.version_info < (3, 11):
+    from exceptiongroup import ExceptionGroup  # pragma: no cover
+
 if TYPE_CHECKING:
     from ._doc import Doc
 
@@ -73,16 +77,42 @@ class Transaction:
         # since nested transactions reuse the root transaction
         if self._leases == 0:
             assert self._txn is not None
-            if not isinstance(self, ReadTransaction):
-                self._txn.commit()
-                origin_hash = self._txn.origin()
-                if origin_hash is not None:
-                    del self._doc._origins[origin_hash]
-                if self._doc._allow_multithreading:
-                    self._doc._txn_lock.release()
-            self._txn.drop()
-            self._txn = None
-            self._doc._txn = None
+            try:
+                if not isinstance(self, ReadTransaction):
+                    self._txn.commit()
+                    origin_hash = self._txn.origin()
+                    if origin_hash is not None:
+                        del self._doc._origins[origin_hash]
+                    if self._doc._allow_multithreading:
+                        self._doc._txn_lock.release()
+                    if self._doc._exceptions:
+                        exceptions = tuple(self._doc._exceptions)
+                        self._doc._exceptions.clear()
+                        raise ExceptionGroup("Observer callback error", exceptions)
+            finally:
+                self._txn.drop()
+                self._txn = None
+                self._doc._txn = None
+
+    async def __aenter__(self, _acquire_transaction: bool = True) -> Transaction:
+        if self._leases > 0 and self._doc._task_group is None:
+            raise RuntimeError("Already in a non-async transaction")
+        self._doc._task_group = await create_task_group().__aenter__()
+        return self.__enter__(_acquire_transaction)
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> bool | None:
+        self.__exit__(exc_type, exc_val, exc_tb)
+        if self._leases == 0:
+            assert self._doc._task_group is not None
+            res = await self._doc._task_group.__aexit__(exc_type, exc_val, exc_tb)
+            self._doc._task_group = None
+            return res
+        return None
 
     @property
     def origin(self) -> Any:
@@ -116,7 +146,7 @@ class NewTransaction(Transaction):
     ```
     """
 
-    async def __aenter__(self) -> Transaction:
+    async def __aenter__(self) -> Transaction:  # type: ignore[override]
         if self._doc._allow_multithreading:
             if not await to_thread.run_sync(
                 partial(self._doc._txn_lock.acquire, timeout=self._timeout), abandon_on_cancel=True
@@ -124,17 +154,18 @@ class NewTransaction(Transaction):
                 raise TimeoutError("Could not acquire transaction")
         else:
             await self._doc._txn_async_lock.acquire()
-        return super().__enter__(_acquire_transaction=False)  # type: ignore[call-arg]
+        return await super().__aenter__(_acquire_transaction=False)
 
     async def __aexit__(
         self,
         exc_type: type[BaseException] | None,
         exc_val: BaseException | None,
         exc_tb: TracebackType | None,
-    ) -> None:
-        super().__exit__(exc_type, exc_val, exc_tb)
+    ) -> bool | None:
+        res = await super().__aexit__(exc_type, exc_val, exc_tb)
         if not self._doc._allow_multithreading:
             self._doc._txn_async_lock.release()
+        return res
 
 
 class ReadTransaction(Transaction):

pycrdt/_undo.py

@@ -37,6 +37,8 @@ class UndoManager:
         scopes: list[BaseType] = [],
         capture_timeout_millis: int = 500,
         timestamp: Callable[[], int] = timestamp,
+        undo_stack: list[StackItem] | None = None,
+        redo_stack: list[StackItem] | None = None,
     ) -> None:
         """
         Args:
@@ -44,6 +46,8 @@ class UndoManager:
             scopes: A list of shared types the undo manager will work with.
             capture_timeout_millis: A time interval for grouping changes that will be undone/redone.
             timestamp: A function that returns a timestamp as an integer number of milli-seconds.
+            undo_stack: Pre-filled undo stack items.
+            redo_stack: Pre-filled redo stack items.
 
         Raises:
             RuntimeError: UndoManager must be created with doc or scopes.
@@ -54,7 +58,13 @@ class UndoManager:
             doc = scopes[0].doc
         elif scopes:
             raise RuntimeError("UndoManager must be created with doc or scopes")
-        self._undo_manager = _UndoManager(doc._doc, capture_timeout_millis, timestamp)
+        self._undo_manager = _UndoManager(
+            doc._doc,
+            capture_timeout_millis,
+            timestamp,
+            undo_stack or [],
+            redo_stack or [],
+        )
         for scope in scopes:
             self.expand_scope(scope)
 

pycrdt/_version.py

@@ -1,10 +1,4 @@
-try:
-    from importlib.metadata import PackageNotFoundError, version
-except ImportError:  # pragma: no cover
-    from importlib_metadata import (  # type: ignore[assignment, import-not-found, no-redef]
-        PackageNotFoundError,
-        version,
-    )
+from importlib.metadata import PackageNotFoundError, version
 
 try:
     __version__ = version("pycrdt")

pycrdt/_xml.py

@@ -269,9 +269,7 @@ class XmlText(_XmlTraitMixin):
                 self._do_and_integrate("insert", value, txn._txn, index, _attrs)
             else:
                 # primitive type
-                self.integrated.insert_embed(
-                    txn._txn, index, value, _attrs
-                )
+                self.integrated.insert_embed(txn._txn, index, value, _attrs)
 
     def format(self, start: int, stop: int, attrs: dict[str, Any]) -> None:
         """

{pycrdt-0.12.35.dist-info → pycrdt-0.12.45.dist-info}/METADATA

@@ -1,26 +1,26 @@
 Metadata-Version: 2.4
 Name: pycrdt
-Version: 0.12.35
+Version: 0.12.45
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.9
 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 :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Dist: anyio>=4.4.0,<5.0.0
-Requires-Dist: importlib-metadata>=3.6 ; python_full_version < '3.10'
 Requires-Dist: typing-extensions>=4.14.0 ; python_full_version < '3.11'
+Requires-Dist: exceptiongroup ; python_full_version < '3.11'
 License-File: LICENSE
 Summary: Python bindings for Yrs
 Keywords: crdt
 Author-email: David Brochart <david.brochart@gmail.com>
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
 Project-URL: Homepage, https://github.com/y-crdt/pycrdt
 

pycrdt-0.12.45.dist-info/RECORD

@@ -0,0 +1,23 @@
+pycrdt/__init__.py,sha256=OPwvLxHB4jU6QfLhzJgDxX3R9j2oXZrTecGxfnK0msA,2227
+pycrdt/_array.py,sha256=sWGBro3o279Cw1_EOTlEWFe51Ymo66Nt-gLPV2cY0p0,14614
+pycrdt/_awareness.py,sha256=1F8olK8EgF6ea2VzeDwHjnoy090cAYOjakwA4yLxWH0,10904
+pycrdt/_base.py,sha256=pXRfzzQkbERczfE6zajduo3LO2myCQAYwxqfyRAHulI,13316
+pycrdt/_doc.py,sha256=AMCeuJLxgTmX1dRWh2aHL_vt31bDxHO5B9TxxQz475s,17282
+pycrdt/_map.py,sha256=N0rBhDfcMmzPfmzZyWP0lJdprGQhjg086-1OlApwEQw,10595
+pycrdt/_provider.py,sha256=RigUnf6S6AWuxxZ7I-oDZYZbjnBZYTMD0It7ADBxsSI,5295
+pycrdt/_pycrdt.cpython-313-powerpc64le-linux-gnu.so,sha256=t01F4Ql88P7XPAkmOaCg9tdCx1h70JvjMGSLoZVanxc,3219184
+pycrdt/_pycrdt.pyi,sha256=MD5A5DOz30dHJuTs_7ooK2svpR_uBnhAVUt9xDznRXQ,17995
+pycrdt/_snapshot.py,sha256=3Yof2MsnKs4T3OlCnBJlxjuvduRViHbtLfN_m65FXqk,1366
+pycrdt/_sticky_index.py,sha256=3-KoFY3fCHTrQrHHtPJkDjTOCX3AGK9fnZNnOg0qqvE,4467
+pycrdt/_sync.py,sha256=-UQaY1M0_g5WKzwHg06FotYdD4KmH5OXyVlHsFYDqjI,7801
+pycrdt/_text.py,sha256=7Z3mGalJcN5q4nbc4cnfr4ISOxTwGjhB5sXsQMgOaE0,10402
+pycrdt/_transaction.py,sha256=6mWwy-7514leTtN02JqNW1hN8O7f0cifx5brACwgGgI,5801
+pycrdt/_undo.py,sha256=-5tu_IKXn1FdUy6Y_heBzV5Z3uu-5wj09QTWlE_LnM0,4390
+pycrdt/_update.py,sha256=VLqfKIab0qlRrHTgWNWjGiULzEC4Zjt-EtN1oltaoJk,1158
+pycrdt/_version.py,sha256=-6olC6rrn13JKphGwX4vnzXh3q4oCrxxJR8STERSBIw,184
+pycrdt/_xml.py,sha256=D7tewpsOD4UYT6yj2J-QRfJY2o_KjIWLXIWQh1WGZkI,18830
+pycrdt/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pycrdt-0.12.45.dist-info/METADATA,sha256=XNWYfFEVi2C71V1SasbH3KJiQY0TYS9jmtxshvVYT7o,1591
+pycrdt-0.12.45.dist-info/WHEEL,sha256=bXGMTa4RzDiUNC4ZGkabASlbeaOQQMA-eyfwmwikwto,149
+pycrdt-0.12.45.dist-info/licenses/LICENSE,sha256=Sesm0tdTWXYb_Om3U3LUusWWhxEyBNO19HXj8nLklfc,1081
+pycrdt-0.12.45.dist-info/RECORD,,

pycrdt-0.12.45.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: maturin (1.11.5)
+Root-Is-Purelib: false
+Tag: cp313-cp313-manylinux_2_17_ppc64le
+Tag: cp313-cp313-manylinux2014_ppc64le

pycrdt-0.12.35.dist-info/RECORD

@@ -1,23 +0,0 @@
-pycrdt-0.12.35.dist-info/METADATA,sha256=ERpYiTH08KiZjcHmbXtiZ2xLkKQ8V6gAHG9BOSIAj6A,1598
-pycrdt-0.12.35.dist-info/WHEEL,sha256=pRcitBs64vnjhhxH8reDexDsugt6T62SWxFe-gRXupU,131
-pycrdt-0.12.35.dist-info/licenses/LICENSE,sha256=Sesm0tdTWXYb_Om3U3LUusWWhxEyBNO19HXj8nLklfc,1081
-pycrdt/__init__.py,sha256=uGg4-TDp_XHh-RM17bWVk_V50Oh4n10MXTS91RLz3cw,2106
-pycrdt/_array.py,sha256=sWGBro3o279Cw1_EOTlEWFe51Ymo66Nt-gLPV2cY0p0,14614
-pycrdt/_awareness.py,sha256=1F8olK8EgF6ea2VzeDwHjnoy090cAYOjakwA4yLxWH0,10904
-pycrdt/_base.py,sha256=q6DNaapYHwzggpEgcEd9t12zI_4rDOqPDKr8XGCYF4Q,12859
-pycrdt/_doc.py,sha256=UrwnqYg_L1ldNTJCXoTY8-P8gnLRpxraR7I1YNYzQm4,14299
-pycrdt/_map.py,sha256=N0rBhDfcMmzPfmzZyWP0lJdprGQhjg086-1OlApwEQw,10595
-pycrdt/_provider.py,sha256=9Jsb7EGjVK1uZ65FfzFypT-eMU_QHnfm_SORfTDSDSU,5333
-pycrdt/_pycrdt.cpython-313-powerpc64le-linux-gnu.so,sha256=P0FkuMPuqrYWYxjdyv3AuYmwwbWkKLk2RLI2WhCy2Xc,3265128
-pycrdt/_pycrdt.pyi,sha256=g8MA2J99XYNulj-YbXgFvngYH23lMAQFUByZLoovXKk,16164
-pycrdt/_snapshot.py,sha256=3Yof2MsnKs4T3OlCnBJlxjuvduRViHbtLfN_m65FXqk,1366
-pycrdt/_sticky_index.py,sha256=3-KoFY3fCHTrQrHHtPJkDjTOCX3AGK9fnZNnOg0qqvE,4467
-pycrdt/_sync.py,sha256=-UQaY1M0_g5WKzwHg06FotYdD4KmH5OXyVlHsFYDqjI,7801
-pycrdt/_text.py,sha256=7Z3mGalJcN5q4nbc4cnfr4ISOxTwGjhB5sXsQMgOaE0,10402
-pycrdt/_transaction.py,sha256=9YfpbZRL9AdxUcWHKsPIxytxVaVSNfF2GEr_3b3DmNc,4477
-pycrdt/_undo.py,sha256=NYvyngRDFtOnWpCS4M5AGwKNYXjgJQMl2fDsG8iZ6oU,4075
-pycrdt/_update.py,sha256=VLqfKIab0qlRrHTgWNWjGiULzEC4Zjt-EtN1oltaoJk,1158
-pycrdt/_version.py,sha256=BO8Bo1LgU5k23oxZQKvoPxnQ2RiKSzM3r_FH1JBBXT4,379
-pycrdt/_xml.py,sha256=jHRpLpC07oH4KDY2RskGQ7HTcMqO-TFQj56xbnnwejM,18870
-pycrdt/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pycrdt-0.12.35.dist-info/RECORD,,

pycrdt-0.12.35.dist-info/WHEEL

@@ -1,4 +0,0 @@
-Wheel-Version: 1.0
-Generator: maturin (1.9.4)
-Root-Is-Purelib: false
-Tag: cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le