quill-delta-python312 0.1__py3-none-any.whl

delta/__init__.py

@@ -0,0 +1,3 @@
+from .base import Delta
+
+__version__ = '1.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

delta/deep_eq.py

@@ -0,0 +1,143 @@
+#Copyright (c) 2010-2013 Samuel Sutch [samuel.sutch@gmail.com]
+#
+#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.
+
+import datetime, time, functools, operator, types
+
+default_fudge = datetime.timedelta(seconds=0, microseconds=0, days=0)
+
+def deep_eq(_v1, _v2, datetime_fudge=default_fudge, _assert=False):
+  """
+  Tests for deep equality between two python data structures recursing 
+  into sub-structures if necessary. Works with all python types including
+  iterators and generators. This function was dreampt up to test API responses
+  but could be used for anything. Be careful. With deeply nested structures
+  you may blow the stack.
+  
+  Options:
+            datetime_fudge => this is a datetime.timedelta object which, when
+                              comparing dates, will accept values that differ
+                              by the number of seconds specified
+            _assert        => passing yes for this will raise an assertion error
+                              when values do not match, instead of returning 
+                              false (very useful in combination with pdb)
+  
+  Doctests included:
+  
+  >>> x1, y1 = ({'a': 'b'}, {'a': 'b'})
+  >>> deep_eq(x1, y1)
+  True
+  >>> x2, y2 = ({'a': 'b'}, {'b': 'a'})
+  >>> deep_eq(x2, y2)
+  False
+  >>> x3, y3 = ({'a': {'b': 'c'}}, {'a': {'b': 'c'}})
+  >>> deep_eq(x3, y3)
+  True
+  >>> x4, y4 = ({'c': 't', 'a': {'b': 'c'}}, {'a': {'b': 'n'}, 'c': 't'})
+  >>> deep_eq(x4, y4)
+  False
+  >>> x5, y5 = ({'a': [1,2,3]}, {'a': [1,2,3]})
+  >>> deep_eq(x5, y5)
+  True
+  >>> x6, y6 = ({'a': [1,'b',8]}, {'a': [2,'b',8]})
+  >>> deep_eq(x6, y6)
+  False
+  >>> x7, y7 = ('a', 'a')
+  >>> deep_eq(x7, y7)
+  True
+  >>> x8, y8 = (['p','n',['asdf']], ['p','n',['asdf']])
+  >>> deep_eq(x8, y8)
+  True
+  >>> x9, y9 = (['p','n',['asdf',['omg']]], ['p', 'n', ['asdf',['nowai']]])
+  >>> deep_eq(x9, y9)
+  False
+  >>> x10, y10 = (1, 2)
+  >>> deep_eq(x10, y10)
+  False
+  >>> deep_eq((str(p) for p in xrange(10)), (str(p) for p in xrange(10)))
+  True
+  >>> str(deep_eq(range(4), range(4)))
+  'True'  
+  >>> deep_eq(xrange(100), xrange(100))
+  True
+  >>> deep_eq(xrange(2), xrange(5))
+  False
+  >>> import datetime
+  >>> from datetime import datetime as dt
+  >>> d1, d2 = (dt.now(), dt.now() + datetime.timedelta(seconds=4))
+  >>> deep_eq(d1, d2)
+  False
+  >>> deep_eq(d1, d2, datetime_fudge=datetime.timedelta(seconds=5))
+  True
+  """
+  _deep_eq = functools.partial(deep_eq, datetime_fudge=datetime_fudge, 
+                               _assert=_assert)
+  
+  def _check_assert(R, a, b, reason=''):
+    if _assert and not R:
+      assert 0, "an assertion has failed in deep_eq (%s) %s != %s" % (
+        reason, str(a), str(b))
+    return R
+  
+  def _deep_dict_eq(d1, d2):
+    k1, k2 = (sorted(d1.keys()), sorted(d2.keys()))
+    if k1 != k2: # keys should be exactly equal
+      return _check_assert(False, k1, k2, "keys")
+    
+    return _check_assert(operator.eq(sum(_deep_eq(d1[k], d2[k]) 
+                                       for k in k1), 
+                                     len(k1)), d1, d2, "dictionaries")
+  
+  def _deep_iter_eq(l1, l2):
+    if len(l1) != len(l2):
+      return _check_assert(False, l1, l2, "lengths")
+    return _check_assert(operator.eq(sum(_deep_eq(v1, v2) 
+                                      for v1, v2 in zip(l1, l2)), 
+                                     len(l1)), l1, l2, "iterables")
+  
+  def op(a, b):
+    _op = operator.eq
+    if type(a) == datetime.datetime and type(b) == datetime.datetime:
+      s = datetime_fudge.seconds
+      t1, t2 = (time.mktime(a.timetuple()), time.mktime(b.timetuple()))
+      l = t1 - t2
+      l = -l if l > 0 else l
+      return _check_assert((-s if s > 0 else s) <= l, a, b, "dates")
+    return _check_assert(_op(a, b), a, b, "values")
+
+  c1, c2 = (_v1, _v2)
+  
+  # guard against strings because they are iterable and their
+  # elements yield iterables infinitely. 
+  # I N C E P T I O N
+  for t in types.StringTypes:
+    if isinstance(_v1, t):
+      break
+  else:
+    if isinstance(_v1, types.DictType):
+      op = _deep_dict_eq
+    else:
+      try:
+        c1, c2 = (list(iter(_v1)), list(iter(_v2)))
+      except TypeError:
+        c1, c2 = _v1, _v2
+      else:
+        op = _deep_iter_eq
+  
+  return op(c1, c2)

delta/html.py

@@ -0,0 +1,332 @@
+import logging
+from functools import wraps
+from .base import Delta
+from lxml.html import HtmlElement, Element
+from lxml import html
+from cssutils import parseStyle
+
+CLASSES = {
+    'font': {
+        'serif': 'ql-font-serif',
+        'monospace': 'ql-font-monospace'
+    },
+    'size': {
+        'small': 'ql-size-small',
+        'large': 'ql-size-large',
+        'huge': 'ql-size-huge',
+    }
+}
+
+CODE_BLOCK_CLASS = 'ql-syntax'
+VIDEO_IFRAME_CLASS = 'ql-video'
+INDENT_CLASS = 'ql-indent-%d'
+DIRECTION_CLASS = 'ql-direction-%s'
+ALIGN_CLASS = 'ql-align-%s'
+
+
+logger = logging.getLogger('quill')
+
+
+### Helpers ###
+def sub_element(root, *a, **kwargs):
+    e = root.makeelement(*a, **kwargs)
+    root.append(e)
+    return e
+
+def styled(element, styles):
+    if element.tag != 'span':
+        element = sub_element(element, 'span')
+    declare = parseStyle(element.attrib.get('style', ''))
+    for k, v in styles.items():
+        declare.setProperty(k, v)
+    element.attrib['style'] = declare.getCssText(' ')
+    return element
+
+def classed(element, *classes):
+    if element.tag != 'span':
+        element = sub_element(element, 'span')
+    return add_class(element, *classes)
+
+def add_class(element, *classes):
+    current = element.attrib.get('class')
+    if current:
+        current = set(current.split())
+    else:
+        current = set()
+    classes = current.union(set(classes))
+    element.attrib['class'] = " ".join(sorted(list(classes)))
+    return element
+
+
+### Registry ###
+class Format:
+    all = []
+
+    def __init__(self, fn, name):
+        self.all.append(self)
+        self.name = name
+        self.fn = fn
+        self.check_fn = None
+    
+    def __repr__(self):
+        return "<%s %r>" % (self.__class__.__name__, self.name)
+
+    def __call__(self, root, op):
+        if self._check(op):
+            try:
+                el = self.fn(root, op)
+            except Exception as e:
+                logger.error("Rendering format failed: %r", e)
+                el = ""
+            return el
+        return root
+
+    def check(self, fn):
+        self.check_fn = fn
+        return fn
+
+    def _check(self, op):
+        if self.check_fn:
+            return self.check_fn(op)
+        
+        attrs = op.get('attributes', None)
+        if attrs and self.name in attrs:
+            return True
+        return False
+
+def format(fn, name=None, cls=Format):
+    if isinstance(fn, str):
+        name = fn
+        def wrapper(fn):
+            return format(fn, name, cls)
+        return wrapper
+    return cls(fn, name or fn.__name__)
+
+
+class BlockFormat(Format):
+    """
+    Block formats change the entire line through the attrs of the endline, not through
+    something like the insert.
+    """
+    all = []
+
+    def __init__(self, fn, name):
+        self.all.append(self)
+        self.name = name
+        self.fn = fn
+        self.check_fn = None
+
+    def __call__(self, root, attrs):
+        if self.name in attrs:
+            root = self.fn(root, attrs)
+        return root
+
+    def __repr__(self):
+        return "<BlockFormat %s>" % self.name
+
+
+### Formats ###
+@format
+def header(root, op):
+    root.tag = 'h%s' % op['attributes']['header']
+    return root
+
+@format
+def strong(root, op):
+    return sub_element(root, 'strong')
+
+@format
+def bold(root, op):
+    return strong.fn(root, op)
+
+@format
+def em(root, op):
+    return sub_element(root, 'em')
+
+@format
+def italic(root, op):
+    return em.fn(root, 'em')
+
+@format
+def underline(root, op):
+    return sub_element(root, 'u')
+
+@format
+def strike(root, op):
+    return sub_element(root, 's')
+
+@format
+def script(root, op):
+    if op['attributes']['script'] == 'super':
+        return sub_element(root, 'sup')
+    if op['attributes']['script'] == 'sub':
+        return sub_element(root, 'sub')
+    return root
+
+@format
+def background(root, op):
+    return styled(root, {'background-color': op['attributes']['background']})
+
+@format
+def color(root, op):
+    return styled(root, {'color': op['attributes']['color']})
+
+@format
+def link(root, op):
+    el = sub_element(root, 'a')
+    link = op['attributes']['link']
+
+    if isinstance(link, str):
+        el.attrib['href'] = op['attributes']['link']
+    elif isinstance(link, dict):
+        for attrname, attrvalue in link.items():
+            el.attrib[attrname] = attrvalue
+
+    return el
+
+@format
+def classes(root, op):
+    attrs = op.get('attributes', None)
+    if attrs:
+        for name, options in CLASSES.items():
+            value = op['attributes'].get(name)
+            if value in options:
+                root = classed(root, options[value])
+    return root
+
+@classes.check
+def classes_check(op):
+    return True
+
+@format
+def image(root, op):
+    el = sub_element(root, 'img')
+    el.attrib['src'] = op['insert']['image']
+    attrs = op.get('attributes', None)
+    if attrs and attrs.get('width', None):
+        el.attrib['width'] = op['attributes']['width']
+    if attrs and attrs.get('height', None):
+        el.attrib['height'] = op['attributes']['height']
+    return el
+
+@image.check
+def image_check(op):
+    insert = op.get('insert')
+    return isinstance(insert, dict) and insert.get('image')
+
+@format
+def video(root, op):
+    attributes = op.get('attributes', {})
+    iframe = root.makeelement('iframe')
+    iframe.attrib.update({
+        'class': VIDEO_IFRAME_CLASS,
+        'frameborder': '0',
+        'allowfullscreen': 'true',
+        'src': op['insert']['video']
+    })
+    if isinstance(attributes, dict) and attributes.get('align', None):
+        align_block(iframe, attributes)
+    root.addprevious(iframe)
+    return iframe
+
+@video.check
+def video_check(op):
+    insert = op.get('insert')
+    return isinstance(insert, dict) and insert.get('video')
+
+
+### Block Formats ###
+LIST_TYPES = {'ordered': 'ol', 'bullet': 'ul'}
+
+@format('indent', cls=BlockFormat)
+def indent(block, attrs):
+    level = attrs['indent']
+    if level >= 1 and level <= 8:
+        return add_class(block, INDENT_CLASS % level)
+    return block
+
+@format('list', cls=BlockFormat)
+def list_block(block, attrs):
+    block.tag = 'li'
+    previous = block.getprevious()
+    list_tag = LIST_TYPES.get(attrs['list'], 'ol')
+    if previous is not None and previous.tag == list_tag:
+        list_el = previous
+    else:
+        list_el = sub_element(block.getparent(), list_tag)
+    list_el.append(block)
+    return block
+
+@format('direction', cls=BlockFormat)
+def list_block(block, attrs):
+    return add_class(block, DIRECTION_CLASS % attrs['direction'])
+
+@format('align', cls=BlockFormat)
+def align_block(block, attrs):
+    return add_class(block, ALIGN_CLASS % attrs['align'])
+
+@format('header', cls=BlockFormat)
+def header_block(block, attrs):
+    block.tag = 'h%s' % attrs['header']
+    return block
+
+@format('blockquote', cls=BlockFormat)
+def blockquote(block, attrs):
+    block.tag = 'blockquote'
+    return block
+
+@format("code-block")
+def code_block(root, op):
+    root.tag = 'pre'
+    root.attrib.update({
+        'class': CODE_BLOCK_CLASS,
+        'spellcheck': 'false'
+    })
+    return root
+
+
+### Processors ###
+def append_op(root, op):
+    for fmt in Format.all:
+        root = fmt(root, op)
+
+    text = op.get('insert')
+    if isinstance(text, str) and text:
+        if list(root):
+            last = root[-1]
+            if last.tail:
+                last.tail += text
+            else:
+                last.tail = text
+        else:
+            if root.text:
+                root.text += text
+            else:
+                root.text = text
+
+
+def append_line(root, delta, attrs, index):
+    block = sub_element(root, 'p')
+    
+    for op in delta.ops:
+        append_op(block, op)
+
+    if len(block) <= 0 and not block.text:
+        br = sub_element(block, 'br')
+
+    for fmt in BlockFormat.all:
+        root = fmt(block, attrs)
+
+
+def render(delta, method='html', pretty=False):
+    if not isinstance(delta, Delta):
+        delta = Delta(delta)
+
+    root = html.fragment_fromstring("<template></template>")
+    for line, attrs, index in delta.iter_lines():
+        append_line(root, line, attrs, index)
+
+    result = "".join(
+        html.tostring(child, method=method, with_tail=True, encoding='unicode', pretty_print=pretty) 
+        for child in root)
+    return result

delta/op.py

@@ -0,0 +1,170 @@
+import copy
+
+
+def compose(a, b, keep_null=False):
+    """
+    Compose two operations into one.
+
+    ``keep_null`` [default=false] is a boolean that controls whether None/Null 
+    attributes are retrained.
+    """
+    if a is None:
+        a = {}
+    if b is None:
+        b = {}
+
+    # deep copy b, but get rid of None values if keep_null is falsey
+    attributes = dict((k, copy.deepcopy(v)) for k, v in b.items() if keep_null or v is not None)
+
+    for k, v in a.items():
+        if k not in b:
+            attributes[k] = copy.deepcopy(v)
+
+    return attributes or None
+
+
+def diff(a, b):
+    """
+    Return the difference between operations a and b.
+    """
+    if a is None:
+        a = {}
+    if b is None:
+        b = {}
+
+    keys = set(a.keys()).union(set(b.keys()))
+
+    attributes = {}
+    for k in keys:
+        av, bv = a.get(k, None), b.get(k, None)
+        if av != bv:
+            attributes[k] = bv
+
+    return attributes or None
+
+
+def transform(a, b, priority=True):
+    """
+    Return the transformation from operation a to b.
+
+    If ``priority`` is falsey [default=True] then just return b.
+    """
+    if a is None:
+        a = {}
+    if b is None:
+        b = {}
+
+    if not priority:
+        return b or None
+    
+    attributes = {}
+    for k, v in b.items():
+        if k not in a:
+            attributes[k] = v
+
+    return attributes or None
+
+
+def length_of(op):
+    typ = type_of(op)
+    if typ == 'delete':
+        return op['delete']
+    elif typ == 'retain':
+        return op['retain']
+    elif isinstance(op.get('insert'), str):
+        return len(op['insert'])
+    else:
+        return 1
+
+
+def type_of(op):
+    if not op:
+        return None
+    if isinstance(op.get('delete'), int):
+        return 'delete'
+    if isinstance(op.get('retain'), int):
+        return 'retain'
+    return 'insert'
+
+
+
+class Iterator(object):
+    """
+    An iterator that enables itself to break off operations
+    to exactly the length needed via the ``next()`` method.
+    """
+    def __init__(self, ops=[]):
+        self.ops = ops
+        self.reset()
+
+    def reset(self):
+        self.index = 0
+        self.offset = 0
+
+    def has_next(self):
+        return self.peek_length() is not None
+
+    def next(self, length=None):
+        offset = self.offset
+
+        op = self.peek()
+        op_type = type_of(op)
+        if op is None:
+            return { 'retain': None }
+        
+        op_length = length_of(op)
+        if (length is None or length >= op_length - offset):
+            length = op_length - offset
+            self.index += 1
+            self.offset = 0
+        else:
+            self.offset += length
+
+        if op_type == 'delete':
+            return { 'delete': length }
+
+        result_op = {}
+        if op.get('attributes'):
+            result_op['attributes'] = op['attributes']
+
+        if op_type == 'retain':
+            result_op['retain'] = length
+        elif isinstance(op.get('insert'), str):
+            result_op['insert'] = op['insert'][offset:offset+length]
+        else:
+            assert offset == 0
+            assert length == 1
+            if 'insert' in op:
+                result_op['insert'] = op['insert']
+
+        return result_op
+
+    __next__ = next
+
+    def __length__(self):
+        return len(self.ops)
+
+    def __iter__(self):
+        return self
+
+    def peek(self):
+        try:
+            return self.ops[self.index]
+        except IndexError:
+            return None
+
+    def peek_length(self):
+        next_op = self.peek()
+        if next_op is None:
+            return None
+        return length_of(next_op) - self.offset
+
+    def peek_type(self):
+        op = self.peek()
+        if op is None:
+            return 'retain'
+        return type_of(op)
+
+length = length_of
+type = type_of
+iterator = lambda x: Iterator(x)

quill_delta_python312-0.1.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,10 @@
+delta/__init__.py,sha256=3YaFu2C462Cj5MdWySBTFBXwHWbPGyGHDpuWkmj0QQI,46
+delta/base.py,sha256=TTUMwdghfhbN7lLr-K7YWwlEpMcNClsBKD1mdBjl1qQ,11092
+delta/deep_eq.py,sha256=yYY2FngVK7syhrnOYCSgNjvQ9VZRexl0IeflvArgiMM,5227
+delta/html.py,sha256=sLao3uc6DC8Mw5VkZos8TuOe2R07-f7kYu6QCvK4qzY,8188
+delta/op.py,sha256=sYHa2uhI6xlctdIUeK_7lk1S-lGOldUdpx6goqvMV-I,3795
+quill_delta_python312-0.1.dist-info/licenses/LICENSE.txt,sha256=dBEV4IpoX-tkLLW75k5Tf2cGf9mVyyNPtkKn0X3eU94,1081
+quill_delta_python312-0.1.dist-info/METADATA,sha256=Z5k4KF2ShbnpDlTSZQi3JuEKNwGglOpCsodYmbio5s0,2772
+quill_delta_python312-0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+quill_delta_python312-0.1.dist-info/top_level.txt,sha256=ZzlT4K1_xTJH9P6twsLUUGOWhA0fh5ZSb0jUczOsdlI,6
+quill_delta_python312-0.1.dist-info/RECORD,,

quill_delta_python312-0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

quill_delta_python312-0.1.dist-info/licenses/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.dist-info/top_level.txt

@@ -0,0 +1 @@
+delta