quill-delta-python312 0.1__tar.gz

quill_delta_python312-0.1/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Brantley Harris
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

quill_delta_python312-0.1/PKG-INFO

@@ -0,0 +1,122 @@
+Metadata-Version: 2.4
+Name: quill-delta-python312
+Version: 0.1
+Summary: Fork of delta-python with dependencies updated for python 3.12 and up
+Home-page: https://github.com/yesyves/quill-delta-python312
+Author: Brantley Harris
+Author-email: brantley@forge.works
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: diff-match-patch>=20181111.0
+Provides-Extra: html
+Requires-Dist: lxml>=6.0; extra == "html"
+Requires-Dist: cssutils>=2.0; extra == "html"
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+
+# Delta (Python Port)
+
+Python port of the javascript Delta library for QuillJS: https://github.com/quilljs/delta
+
+Some basic pythonizing has been done, but mostly it works exactly like the above library.
+
+There is no other python specific documentation at this time, sorry.  Please see the tests
+for reference examples.
+
+## Install with [Poetry](https://poetry.eustace.io/docs/#installation)
+
+With HTML rendering:
+
+    > poetry add -E html quill-delta
+
+Without HTML rendering:
+
+    > poetry add quill-delta
+
+## Install with pip
+
+Note: If you're using `zsh`, see below.
+
+With HTML rendering:
+
+    > pip install quill-delta[html]
+
+With HTML rendering (zsh):
+
+    > pip install quill-delta"[html]"
+
+Without HTML rendering:
+
+    > pip install quill-delta
+
+
+# Rendering HTML in Python
+
+This library includes a module `delta.html` that renders html from an operation list,
+allowing you to render Quill Delta operations in full from a Python server.
+
+For example:
+
+    from delta import html
+
+    ops = [ 
+        { "insert":"Quill\nEditor\n\n" },
+        { "insert": "bold",
+          "attributes": {"bold": True}},
+        { "insert":" and the " },
+        { "insert":"italic",
+          "attributes": { "italic": True }},
+        { "insert":"\n\nNormal\n" },
+    ]
+
+    html.render(ops)
+
+Result (line formatting added for readability):
+    
+    <p>Quill</p>
+    <p>Editor</p>
+    <p><br></p>
+    <p><strong>bold</strong> and the <em>italic</em></p>
+    <p><br></p>
+    <p>Normal</p>
+
+[See test_html.py](tests/test_html.py) for more examples.
+
+
+# Developing
+
+## Setup
+If you'd to contribute to quill-delta-python, get started setting your development environment by running:
+
+Checkout the repository
+
+    > git clone https://github.com/forgeworks/quill-delta-python.git
+
+Make sure you have python 3 installed, e.g.,
+
+    > python --version
+
+From inside your new quill-delta-python directory:
+
+    > python3 -m venv env
+    > source env/bin/activate
+    > pip install poetry
+    > poetry install -E html
+
+## Tests
+To run tests do:
+
+    > py.test
+
+
+

quill_delta_python312-0.1/README.md

@@ -0,0 +1,97 @@
+
+# Delta (Python Port)
+
+Python port of the javascript Delta library for QuillJS: https://github.com/quilljs/delta
+
+Some basic pythonizing has been done, but mostly it works exactly like the above library.
+
+There is no other python specific documentation at this time, sorry.  Please see the tests
+for reference examples.
+
+## Install with [Poetry](https://poetry.eustace.io/docs/#installation)
+
+With HTML rendering:
+
+    > poetry add -E html quill-delta
+
+Without HTML rendering:
+
+    > poetry add quill-delta
+
+## Install with pip
+
+Note: If you're using `zsh`, see below.
+
+With HTML rendering:
+
+    > pip install quill-delta[html]
+
+With HTML rendering (zsh):
+
+    > pip install quill-delta"[html]"
+
+Without HTML rendering:
+
+    > pip install quill-delta
+
+
+# Rendering HTML in Python
+
+This library includes a module `delta.html` that renders html from an operation list,
+allowing you to render Quill Delta operations in full from a Python server.
+
+For example:
+
+    from delta import html
+
+    ops = [ 
+        { "insert":"Quill\nEditor\n\n" },
+        { "insert": "bold",
+          "attributes": {"bold": True}},
+        { "insert":" and the " },
+        { "insert":"italic",
+          "attributes": { "italic": True }},
+        { "insert":"\n\nNormal\n" },
+    ]
+
+    html.render(ops)
+
+Result (line formatting added for readability):
+    
+    <p>Quill</p>
+    <p>Editor</p>
+    <p><br></p>
+    <p><strong>bold</strong> and the <em>italic</em></p>
+    <p><br></p>
+    <p>Normal</p>
+
+[See test_html.py](tests/test_html.py) for more examples.
+
+
+# Developing
+
+## Setup
+If you'd to contribute to quill-delta-python, get started setting your development environment by running:
+
+Checkout the repository
+
+    > git clone https://github.com/forgeworks/quill-delta-python.git
+
+Make sure you have python 3 installed, e.g.,
+
+    > python --version
+
+From inside your new quill-delta-python directory:
+
+    > python3 -m venv env
+    > source env/bin/activate
+    > pip install poetry
+    > poetry install -E html
+
+## Tests
+To run tests do:
+
+    > py.test
+
+
+

quill_delta_python312-0.1/delta/__init__.py

@@ -0,0 +1,3 @@
+from .base import Delta
+
+__version__ = '1.0.1'

quill_delta_python312-0.1/delta/base.py

@@ -0,0 +1,330 @@
+import copy
+import diff_match_patch
+
+try:
+    from functools import reduce
+except:
+    pass
+
+from . import op
+
+
+NULL_CHARACTER = chr(0)
+DIFF_EQUAL = 0
+DIFF_INSERT = 1
+DIFF_DELETE = -1
+
+
+def merge(a, b):
+    return copy.deepcopy(a or {}).update(b or {})
+
+def differ(a, b, timeout=1):
+    differ = diff_match_patch.diff_match_patch()
+    differ.Diff_Timeout = timeout
+    return differ.diff_main(a, b)
+
+def smallest(*parts):
+    return min(filter(lambda x: x is not None, parts))
+
+
+class Delta(object):
+    def __init__(self, ops=None, **attrs):
+        if hasattr(ops, 'ops'):
+            ops = ops.ops
+        self.ops = ops or []
+        self.__dict__.update(attrs)
+
+    def __eq__(self, other):
+        return self.ops == other.ops
+
+    def __repr__(self):
+        return "{}({})".format(self.__class__.__name__, self.ops)
+
+    def insert(self, text, **attrs):
+        if text == "":
+            return self
+        new_op = {'insert': text}
+        if attrs:
+            new_op['attributes'] = attrs
+        return self.push(new_op)
+
+    def delete(self, length):
+        if length <= 0:
+            return self
+        return self.push({'delete': length});
+
+    def retain(self, length, **attrs):
+        if length <= 0:
+            return self
+        new_op = {'retain': length}
+        if attrs:
+            new_op['attributes'] = attrs
+        return self.push(new_op)
+
+    def push(self, operation):
+        index = len(self.ops)
+        new_op = copy.deepcopy(operation)
+        try:
+            last_op = self.ops[index - 1]
+        except IndexError:
+            self.ops.append(new_op)
+            return self
+        
+        if op.type(new_op) == op.type(last_op) == 'delete':
+            last_op['delete'] += new_op['delete']
+            return self
+
+        if op.type(last_op) == 'delete' and op.type(new_op) == 'insert':
+            index -= 1
+            try:
+                last_op = self.ops[index - 1]
+            except IndexError:
+                self.ops.insert(0, new_op)
+                return self
+
+        if new_op.get('attributes') == last_op.get('attributes'):
+            if isinstance(new_op.get('insert'), str) and isinstance(last_op.get('insert'), str):
+                last_op['insert'] += new_op['insert']
+                return self
+
+            if isinstance(new_op.get('retain'), int) and isinstance(last_op.get('retain'), int):
+                last_op['retain'] += new_op['retain']
+                return self
+
+        self.ops.insert(index, new_op)
+        return self
+
+    def extend(self, ops):
+        if hasattr(ops, 'ops'):
+            ops = ops.ops
+        if not ops:
+            return self
+        self.push(ops[0])
+        self.ops.extend(ops[1:])
+        return self
+
+    def concat(self, other):
+        delta = self.__class__(copy.deepcopy(self.ops))
+        delta.extend(other)
+        return delta
+
+    def chop(self):
+        try:
+            last_op = self.ops[-1]
+            if op.type(last_op) == 'retain' and not last_op.get('attributes'):
+                self.ops.pop()
+        except IndexError:
+            pass
+        return self
+
+    def document(self):
+        parts = []
+        for op in self:
+            insert = op.get('insert')
+            if insert:
+                if isinstance(insert, str):
+                    parts.append(insert)
+                else:
+                    parts.append(NULL_CHARACTER)
+            else:
+                raise ValueError("document() can only be called on Deltas that have only insert ops")
+        return "".join(parts)
+
+    def __iter__(self):
+        return iter(self.ops)
+
+    def __getitem__(self, index):
+        if isinstance(index, int):
+            start = index
+            stop = index + 1
+
+        elif isinstance(index, slice):
+            start = index.start or 0
+            stop = index.stop or None
+
+            if index.step is not None:
+                print(index)
+                raise ValueError("no support for step slices")
+
+        if (start is not None and start < 0) or (stop is not None and stop < 0):
+            raise ValueError("no support for negative indexing.")
+
+        ops = []
+        iter = self.iterator()
+        index = 0
+        while iter.has_next():
+            if stop is not None and index >= stop:
+                break
+            if index < start:
+                next_op = iter.next(start - index)
+            else:
+                if stop is not None:
+                    next_op = iter.next(stop-index)
+                else:
+                    next_op = iter.next()
+                ops.append(next_op)
+            index += op.length(next_op)
+
+        return Delta(ops)
+
+    def __len__(self):
+        return sum(op.length(o) for o in self.ops)
+
+    def iterator(self):
+        return op.iterator(self.ops)
+
+    def change_length(self):
+        length = 0
+        for operator in self:
+            if op.type(operator) == 'delete':
+                length -= operator['delete']
+            else:
+                length += op.length(operator)
+        return length
+
+    def length(self):
+        return sum(op.length(o) for o in self)
+
+    def compose(self, other):
+        self_it = self.iterator()
+        other_it = other.iterator()
+        delta = self.__class__()
+        while self_it.has_next() or other_it.has_next():
+            if other_it.peek_type() == 'insert':
+                delta.push(other_it.next())
+            elif self_it.peek_type() == 'delete':
+                delta.push(self_it.next())
+            else:
+                length = smallest(self_it.peek_length(), other_it.peek_length())
+                self_op = self_it.next(length)
+                other_op = other_it.next(length)
+                if 'retain' in other_op:
+                    new_op = {}
+                    if 'retain' in self_op:
+                        new_op['retain'] = length
+                    elif 'insert' in self_op:
+                        new_op['insert'] = self_op['insert']
+                    # Preserve null when composing with a retain, otherwise remove it for inserts
+                    attributes = op.compose(self_op.get('attributes'), other_op.get('attributes'), isinstance(self_op.get('retain'), int))
+                    if (attributes):
+                        new_op['attributes'] = attributes
+                    delta.push(new_op)
+                # Other op should be delete, we could be an insert or retain
+                # Insert + delete cancels out
+                elif op.type(other_op) == 'delete' and 'retain' in self_op:
+                    delta.push(other_op)
+        return delta.chop()
+    
+    def diff(self, other):
+        """
+        Returns a diff of two *documents*, which is defined as a delta
+        with only inserts. 
+        """
+        if self.ops == other.ops:
+            return self.__class__()
+        
+        self_doc = self.document()
+        other_doc = other.document()
+        self_it = self.iterator()
+        other_it = other.iterator()
+        
+        delta = self.__class__()
+        for code, text in differ(self_doc, other_doc):
+            length = len(text)
+            while length > 0:
+                op_length = 0
+                if code == DIFF_INSERT:
+                    op_length = min(other_it.peek_length(), length)
+                    delta.push(other_it.next(op_length))
+                elif code == DIFF_DELETE:
+                    op_length = min(length, self_it.peek_length())
+                    self_it.next(op_length)
+                    delta.delete(op_length)
+                elif code == DIFF_EQUAL:
+                    op_length = min(self_it.peek_length(), other_it.peek_length(), length)
+                    self_op = self_it.next(op_length)
+                    other_op = other_it.next(op_length)
+                    if self_op.get('insert') == other_op.get('insert'):
+                        attributes = op.diff(self_op.get('attributes'), other_op.get('attributes'))
+                        delta.retain(op_length, **(attributes or {}))
+                    else:
+                        delta.push(other_op).delete(op_length)
+                else:
+                    raise RuntimeError("Diff library returned unknown op code: %r", code)
+                if op_length == 0:
+                    return
+                length -= op_length
+        return delta.chop()
+
+    def each_line(self, fn, newline='\n'):
+        for line, attributes, index in self.iter_lines():
+            if fn(line, attributes, index) is False:
+                break
+
+    def iter_lines(self, newline='\n'):
+        iter = self.iterator()
+        line = self.__class__()
+        i = 0
+        while iter.has_next():
+            if iter.peek_type() != 'insert':
+                return
+            self_op = iter.peek()
+            start = op.length(self_op) - iter.peek_length()
+            if isinstance(self_op.get('insert'), str):
+                index = self_op['insert'][start:].find(newline)
+            else:
+                index = -1
+            
+            if index < 0:
+                line.push(iter.next())
+            elif index > 0:
+                line.push(iter.next(index))
+            else:
+                yield line, iter.next(1).get('attributes', {}), i
+                i += 1
+                line = Delta()
+        if len(line) > 0:
+            yield line, {}, i
+
+    def transform(self, other, priority=False):
+        if isinstance(other, int):
+            return self.transform_position(other, priority)
+
+        self_it = self.iterator()
+        other_it = other.iterator()
+        delta = Delta()
+
+        while self_it.has_next() or other_it.has_next():
+            if self_it.peek_type() == 'insert' and (priority or other_it.peek_type() != 'insert'):
+                delta.retain(op.length(self_it.next()))
+            elif other_it.peek_type() == 'insert':
+                delta.push(other_it.next())
+            else:
+                length = smallest(self_it.peek_length(), other_it.peek_length())
+                self_op = self_it.next(length)
+                other_op = other_it.next(length)
+                if self_op.get('delete'):
+                    # Our delete either makes their delete redundant or removes their retain
+                    continue
+                elif other_op.get('delete'):
+                    delta.push(other_op)
+                else:
+                    # We retain either their retain or insert
+                    delta.retain(length, **(op.transform(self_op.get('attributes'), other_op.get('attributes'), priority) or {}))
+
+        return delta.chop()
+
+    def transform_position(self, index, priority=False):
+        iter = self.iterator()
+        offset = 0
+        while iter.has_next() and offset <= index:
+            length = iter.peek_length()
+            next_type = iter.peek_type()
+            iter.next()
+            if next_type == 'delete':
+                index -= min(length, index - offset)
+                continue
+            elif next_type == 'insert' and (offset < index or not priority):
+                index += length
+            offset += length
+        return index