Prezentprogramo 3.1__py3-none-any.whl

hovercraft/parse.py

@@ -0,0 +1,275 @@
+from docutils import nodes
+from docutils.core import publish_string
+from docutils.readers.standalone import Reader
+from docutils.transforms.misc import Transitions
+from docutils.writers.docutils_xml import Writer
+from lxml import etree
+
+
+class HovercraftTransitions(Transitions):
+    @property
+    def _doc_transitions(self):
+        if not hasattr(self.document, "_transitions"):
+            self.document._transitions = []
+        return self.document._transitions
+
+    def visit_transition(self, node):
+        # First add the level of the transition as a class
+        char = node.rawsource[0]
+        if char not in self._doc_transitions:
+            self._doc_transitions.append(char)
+        level = self._doc_transitions.index(char) + 1
+        node.attributes["level"] = str(level)
+
+        index = node.parent.index(node)
+        error = None
+        # Here the default transformer complained if you had a transition as
+        # the first thing in a section. I don't see why.
+        if isinstance(node.parent[index - 1], nodes.transition):
+            error = self.document.reporter.error(
+                "At least one body element must separate transitions; "
+                "adjacent transitions are not allowed.",
+                source=node.source,
+                line=node.line,
+            )
+        if error:
+            # Insert before node and update index.
+            node.parent.insert(index, error)
+            index += 1
+        assert index < len(node.parent)
+        if index != len(node.parent) - 1:
+            # No need to move the node.
+            return
+        # Node behind which the transition is to be moved.
+        sibling = node
+        # While sibling is the last node of its parent.
+        while index == len(sibling.parent) - 1:
+            sibling = sibling.parent
+            # If sibling is the whole document (i.e. it has no parent).
+            if sibling.parent is None:
+                # Transition at the end of document.  Do not move the
+                # transition up, and place an error behind.
+                error = self.document.reporter.error(
+                    "Document may not end with a transition.", line=node.line
+                )
+                node.parent.insert(node.parent.index(node) + 1, error)
+                return
+            index = sibling.parent.index(sibling)
+        # Remove the original transition node.
+        node.parent.remove(node)
+        # Insert the transition after the sibling.
+        sibling.parent.insert(index + 1, node)
+
+
+class HovercraftReader(Reader):
+    def get_transforms(self):
+        transforms = Reader().get_transforms()
+        transforms.remove(Transitions)
+        transforms.append(HovercraftTransitions)
+        return transforms
+
+
+def rst2xml(rststring, source_path=None):
+    reader = HovercraftReader()
+    writer = Writer()
+    result = publish_string(
+        rststring,
+        source_path=source_path,
+        reader=reader,
+        writer=writer,
+        settings_overrides={"syntax_highlight": "short"},
+    )
+    dependencies = reader.settings.record_dependencies.list
+    return result, dependencies
+
+
+def copy_node(node):
+    """Makes a copy of a node with the same attributes and text, but no children."""
+    element = node.makeelement(node.tag)
+    element.text = node.text
+    element.tail = node.tail
+    for key, value in node.items():
+        element.set(key, value)
+
+    return element
+
+
+class SlideMaker(object):
+    """A docutils XML walker that will organize the XML into slides"""
+
+    def __init__(self, intree, skip_notes=False):
+        self.intree = intree
+        self.result = None
+        self.curnode = None
+        self.steps = 0
+        self.skip_notes = skip_notes
+        self.skip_nodes = (
+            "docinfo",
+            "field_list",
+            "field",
+            "field_body",
+        )
+        self.need_mathjax = False
+        self.lists_with_substeps = []
+
+    def _newstep(self, level):
+        step = etree.Element(
+            "step",
+            attrib={
+                "step": str(self.steps),
+                "class": "step step-level-%s" % level,
+            },
+        )
+        self.steps += 1
+        return step
+
+    def walk(self):
+        walken = etree.iterwalk(self.intree, events=("start", "end"))
+        for event, node in walken:
+            if node.tag in self.skip_nodes:
+                continue
+            method = getattr(self, "%s_%s" % (event, node.tag), None)
+            if method is None:
+                if event == "start":
+                    self.default_start(node)
+                else:
+                    if event == "end":
+                        self.default_end(node)
+            else:
+                method(node)
+
+        return self.result
+
+    def default_start(self, node):
+        new = copy_node(node)
+        self.curnode.append(new)
+        self.curnode = new
+
+    def default_end(self, node):
+        if self.curnode.tag != "step":
+            self.curnode = self.curnode.getparent()
+
+    def start_document(self, node):
+        self.curnode = self.result = copy_node(node)
+
+    def start_section(self, node):
+        # If there has been no transition by now, start a new step:
+        if self.steps == 0:
+            step = self._newstep(1)
+            self.result.append(step)
+            self.curnode = step
+
+        # Then carry on as normal
+        self.default_start(node)
+
+    def start_transition(self, node):
+        level = int(node.attrib["level"])
+        step = self._newstep(level)
+        # Walk back up to a transition of the same level
+        curnode = self.curnode
+
+        def get_level(clss):
+            for cls in clss.split():
+                # Skip unrelated classes, such as those added by the user.
+                if cls.startswith("step-level-"):
+                    return int(cls.split("-")[-1])
+
+        while curnode.tag != "step" or get_level(curnode.attrib["class"]) >= level:
+            parent = curnode.getparent()
+            if parent is None:
+                # Top of tree
+                break
+            curnode = parent
+
+        # This is the transition above the new transition.
+        # Add the new transition to the end.
+        curnode.append(step)
+        self.curnode = step
+
+    def end_transition(self, node):
+        self.default_end(node)
+
+    def start_field_name(self, node):
+        # Fields are made into attribute, nothing to do here:.
+        pass
+
+    def end_field_name(self, node):
+        # Fields are made into attributes
+        pass
+
+    def start_paragraph(self, node):
+        # Fields are made into attributes.
+        parent = node.getparent()
+        if parent.tag == "field_body":
+            fieldname = parent.getprevious().text
+            current = self.curnode.get(fieldname)
+            if current:
+                value = current + " " + node.text
+            else:
+                value = node.text
+            self.curnode.set(fieldname, value)
+        else:
+            self.default_start(node)
+
+    def end_paragraph(self, node):
+        parent = node.getparent()
+        if parent.tag != "field_body":
+            self.default_end(node)
+
+    def start_note(self, node):
+        if not self.skip_notes:
+            return self.default_start(node)
+        # Skip this node completely, including children:
+        while len(node) > 0:
+            del node[0]
+
+    def start_math_block(self, node):
+        self.need_mathjax = True
+        self.default_start(node)
+
+    def start_math(self, node):
+        self.need_mathjax = True
+        self.default_start(node)
+
+    def start_list_item(self, node):
+        if self.lists_with_substeps:
+            # We are currently in a list hierarchy that should have
+            # substeps
+            classes = node.attrib.get("classes", "")
+            if "substep" not in classes:
+                classes += " substep"
+                node.attrib["classes"] = classes.strip()
+
+        self.default_start(node)
+
+    def _fix_substep_list(self, node):
+        # The list istelf should not have the substep class.
+        # For some reason we can't modify nodes in the end_...() functions,
+        # only in the start_...() functions, so we drop the substep class
+        # but add the node to a stack of nodes with the class
+        classes = node.attrib.get("classes", "")
+        if "substep" in classes:
+            self.lists_with_substeps.append(node)
+            classes = classes.replace("substep", "").strip()
+            if not classes:
+                del node.attrib["classes"]
+            else:
+                node.attrib["classes"] = classes
+
+    def start_enumerated_list(self, node):
+        self._fix_substep_list(node)
+        self.default_start(node)
+
+    def end_enumerated_list(self, node):
+        if node in self.lists_with_substeps:
+            self.lists_with_substeps.remove(node)
+        self.default_end(node)
+
+    def start_bullet_list(self, node):
+        self._fix_substep_list(node)
+        self.default_start(node)
+
+    def end_bullet_list(self, node):
+        if node in self.lists_with_substeps:
+            self.lists_with_substeps.remove(node)
+        self.default_end(node)

hovercraft/position.py

@@ -0,0 +1,269 @@
+import math
+
+from svg.path import parse_path
+
+DEFAULT_MOVEMENT = 1600  # If no other movement is specified, go 1600px to the right.
+POSITION_ATTRIBS = [
+    "data-x",
+    "data-y",
+    "data-z",
+    "data-rotate-x",
+    "data-rotate-y",
+    "data-rotate-z",
+    "data-scale",
+]
+
+
+def gather_positions(
+    tree, default_movement_from_args, default_movement_from_data_width
+):
+    """Makes a list of positions and position commands from the tree"""
+    pos = {
+        "data-x": "r0",
+        "data-y": "r0",
+        "data-z": "r0",
+        "data-rotate-x": "r0",
+        "data-rotate-y": "r0",
+        "data-rotate-z": "r0",
+        "data-scale": "r0",
+        "is_path": False,
+    }
+
+    steps = 0
+    default_movement = True
+
+    for step in tree.findall("step"):
+        steps += 1
+
+        for key in POSITION_ATTRIBS:
+            value = step.get(key)
+
+            if value is not None:
+                # We have a new value
+                default_movement = False  # No longer use the default movement
+                pos[key] = value
+            elif pos[key] and not pos[key].startswith("r"):
+                # The old value was absolute and no new value, so stop
+                pos[key] = "r0"
+            # We had no new value, and the old value was a relative
+            # movement, so we just keep moving.
+
+        if steps == 1 and pos["data-scale"] == "r0":
+            # No scale given for first slide, it needs to start at 1
+            pos["data-scale"] = "1"
+
+        if default_movement and steps != 1:
+            # No positioning has been given, use args:
+            if default_movement_from_args:
+                pos["data-x"] = "r%s" % default_movement_from_args
+            else:
+                if (
+                    default_movement_from_data_width
+                    and int(default_movement_from_data_width) > DEFAULT_MOVEMENT
+                ):
+                    pos["data-x"] = "r%s" % default_movement_from_data_width
+                else:
+                    # No positioning has been given, use default:
+                    pos["data-x"] = "r%s" % DEFAULT_MOVEMENT
+
+        if "data-rotate" in step.attrib:
+            # data-rotate is an alias for data-rotate-z
+            pos["data-rotate-z"] = step.get("data-rotate")
+            del step.attrib["data-rotate"]
+
+        if "hovercraft-path" in step.attrib:
+            # Path given x and y will be calculated from the path
+            default_movement = False  # No longer use the default movement
+            pos["is_path"] = True
+            # Add the path spec
+            pos["path"] = step.attrib["hovercraft-path"]
+            yield pos.copy()
+            # And get rid of it for the next step
+            del pos["path"]
+        else:
+            if "data-x" in step.attrib or "data-y" in step.attrib:
+                # No longer using a path
+                pos["is_path"] = False
+            yield pos.copy()
+
+
+def _coord_to_pos(coord):
+    return {"data-x": int(coord.real), "data-y": int(coord.imag)}
+
+
+def _pos_to_cord(coord):
+    return coord["data-x"] + coord["data-y"] * 1j
+
+
+def _path_angle(path, point):
+    start = point - 0.01
+    end = point + 0.01
+    if start < 0:
+        start = 0
+        end += 0.01
+    elif end > 1:
+        end = 1
+        start -= 0.01
+
+    distance = path.point(end) - path.point(start)
+    hyp = math.hypot(distance.real, distance.imag)
+    result = math.degrees(math.asin(distance.imag / hyp))
+
+    if distance.real < 0:
+        result = -180 - result
+
+    if abs(result) < 0.1:
+        result = 0
+
+    return result
+
+
+def num(s):
+    try:
+        return int(s)
+    except ValueError:
+        return float(s)
+
+
+def _update_position(pos1, pos2):
+
+    for key in POSITION_ATTRIBS:
+        val = pos2.get(key)
+        if val is not None:
+            plus = val.find("+")
+            minus = val.find("-")
+            if plus > -1:
+                newval = num(val[plus + 1 :])
+                pos1[key + "-rel"] = val[0:plus]
+            elif minus > -1 and not val.startswith("r-"):
+                newval = num(val[minus:])
+                pos1[key + "-rel"] = val[0:minus]
+            else:
+                if val[0] == "r":
+                    # Relative movement
+                    newval = pos1[key] + num(val[1:])
+                else:
+                    newval = num(val)
+                    pos1.pop(key + "-rel", None)
+            pos1[key] = newval
+
+
+def calculate_positions(positions):
+    """Calculates position information"""
+    current_position = {
+        "data-x": 0,
+        "data-y": 0,
+        "data-z": 0,
+        "data-rotate-x": 0,
+        "data-rotate-y": 0,
+        "data-rotate-z": 0,
+        "data-scale": 1,
+    }
+
+    positer = iter(positions)
+    position = next(positer)
+    _update_position(current_position, position)
+
+    while True:
+
+        if "path" in position:
+            # Start of a new path!
+            path = position["path"]
+            # Follow the path specification
+            first_point = _pos_to_cord(current_position)
+
+            # Paths that end in Z or z are closed.
+            closed_path = path.strip()[-1].upper() == "Z"
+            path = parse_path(path)
+
+            # Find out how many positions should be calculated:
+            count = 1
+            last = False
+            deferred_positions = []
+            while True:
+                try:
+                    position = next(positer)
+                    deferred_positions.append(position)
+                except StopIteration:
+                    last = True  # This path goes to the end
+                    break
+                if not position.get("is_path") or "path" in position:
+                    # The end of the path, or the start of a new one
+                    break
+                count += 1
+
+            if count < 2:
+                raise AssertionError(
+                    "The path specification is only used for "
+                    "one slide, which makes it pointless."
+                )
+
+            if closed_path:
+                # This path closes in on itself. Skip the last part, so that
+                # the first and last step doesn't overlap.
+                endcount = count + 1
+            else:
+                endcount = count
+
+            multiplier = (endcount * DEFAULT_MOVEMENT) / path.length()
+            offset = path.point(0)
+
+            path_iter = iter(deferred_positions)
+            for x in range(count):
+
+                point = path.point(x / (endcount - 1))
+                point = ((point - offset) * multiplier) + first_point
+
+                current_position.update(_coord_to_pos(point))
+
+                rotation = _path_angle(path, x / (endcount - 1))
+                current_position["data-rotate-z"] = rotation
+                yield current_position.copy()
+                try:
+                    position = next(path_iter)
+                except StopIteration:
+                    last = True
+                    break
+                _update_position(current_position, position)
+
+            if last:
+                break
+
+            continue
+
+        yield current_position.copy()
+        try:
+            position = next(positer)
+        except StopIteration:
+            break
+        _update_position(current_position, position)
+
+
+def update_positions(tree, positions):
+    """Updates the tree with new positions"""
+
+    for step, pos in zip(tree.findall("step"), positions):
+        for key in sorted(pos):
+            value = pos.get(key)
+            if key.endswith("-rel"):
+                abs_key = key[: key.index("-rel")]
+                if value is not None:
+                    els = tree.findall(".//*[@id='" + value + "']")
+                    for el in els:
+                        pos[abs_key] = num(el.get(abs_key)) + pos.get(abs_key)
+                        step.attrib[abs_key] = str(pos.get(abs_key))
+            else:
+                step.attrib[key] = str(pos[key])
+
+        if "hovercraft-path" in step.attrib:
+            del step.attrib["hovercraft-path"]
+
+
+def position_slides(tree, default_movement_from_args, default_movement_from_data_width):
+    """Position the slides in the tree"""
+
+    positions = gather_positions(
+        tree, default_movement_from_args, default_movement_from_data_width
+    )
+    positions = calculate_positions(positions)
+    update_positions(tree, positions)