Excalidraw-Interface 0.0.1__py3-none-any.whl

Excalidraw_Interface/LICENSE

@@ -0,0 +1,9 @@
+Modified by Robert Nies
+
+Copyright (c) 2023 Aditya Ganeshan
+
+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.

Excalidraw_Interface/__init__.py

@@ -0,0 +1,6 @@
+from Excalidraw_Interface.sketch_builder import SketchBuilder
+from Excalidraw_Interface.primitives import Group
+
+#TODO - write readme
+#TODO - publish to pypi
+#TODO - tests (check against specific keys from json)

Excalidraw_Interface/defaults.py

@@ -0,0 +1,54 @@
+"""Specify the default values for excalidraw primitives."""
+import os
+
+# Font family for estimating font size
+current_file_dir = os.path.dirname(os.path.abspath(__file__))
+_fonts = {
+    1: "fonts/Virgil.ttf",
+    2: "fonts/Assistant-VariableFont.ttf",
+    3: "fonts/CascadiaCode.ttf",
+}
+FONT_FAMILY = {x: os.path.join(current_file_dir, y) for x, y in _fonts.items()}
+
+# Settings for Rectangle, Ellipse, Diamond
+BOX_DEFAULTS = dict(
+    angle=0,
+    strokeColor="#000000",
+    backgroundColor="transparent",
+    fillStyle="hachure",
+    strokeStyle="solid",
+    strokeWidth=1,
+    roughness=0,
+    opacity=100,
+    roundness={"type": 3},
+    version=1,
+    versionNonce=0,
+    isDeleted=False,
+    boundElements=[],
+    updated=0,
+    link=None,
+    locked=False,
+)
+
+# Extra properties for Text
+TEXT_DEFAULTS = dict(
+    fontSize=20,
+    fontFamily=3,
+    textAlign="left",
+    verticalAlign="top",
+    baseline=18,
+    containerId=None,
+    originalText="default text",
+    roundness=None,
+)
+
+
+# Extra properties for Line
+LINE_DEFAULTS = dict(
+    lastCommitedPoint=None,
+    startBinding=None,
+    endBinding=None,
+    startArrowhead=None,
+    endArrowhead=None,
+    roundess={"type": 2},  # It has only two configurations None and type 2
+)

Excalidraw_Interface/examples/advanced_groups.py

@@ -0,0 +1,16 @@
+from Excalidraw_Interface import SketchBuilder, Group
+
+sb = SketchBuilder()
+
+tb_1 = sb.TextBox('Start Here', 0.5, 0.5)
+tb_2 = sb.TextBox('End Here', 100, 100)
+
+group_1 = Group([tb_1, tb_2])
+bound_1 = sb.create_bounding_element(group_1)
+
+hcb = sb.HeaderContentBox('Header', 'Some Extremely Long Content', 200, 200)
+
+group_2 = Group([bound_1, hcb])
+sb.create_bounding_element(group_2, strokeColor="#FF0000",)
+
+sb.export_to_file('out.excalidraw')

Excalidraw_Interface/examples/flowchart.py

@@ -0,0 +1,20 @@
+from Excalidraw_Interface import SketchBuilder
+
+flowchart_items = ['First Step', 'Second Step', 'Third Step']
+
+sb = SketchBuilder() # Create a Sketch
+
+prev_item = sb.TextBox("Start Here", x = 0, y = 0) # Create a Text Box
+for index, item in enumerate(flowchart_items):
+    new_item = sb.TextBox(item, x = 0, y = (index+1) * 150) # Create a Text Box
+    sb.create_binding_arrows(prev_item, new_item) # Create arrows between boxes
+    prev_item = new_item
+
+hcb = sb.HeaderContentBox("Header", "Content", x = -200, y = 400) # Create a multiline text box
+circle = sb.Ellipse(200, 400, width=50, height=50, backgroundColor = 'red',
+                    roughness=1) # Create a red circle in hand drawn style
+
+sb.create_binding_arrows(prev_item, hcb, sb.DoubleArrow) # Create a double headed arrow
+sb.create_binding_arrows(prev_item, circle, strokeColor = 'blue') # Create an blue arrow
+
+sb.export_to_file('out.excalidraw')

Excalidraw_Interface/primitives.py

@@ -0,0 +1,206 @@
+from Excalidraw_Interface.defaults import FONT_FAMILY
+from PIL import ImageFont
+import random
+import uuid
+import math
+import copy
+
+class ExcaliDrawPrimitive:
+    """
+    Base class for all excalidraw primitives
+    """
+
+    def __init__(self, excal_type: str, default_config: dict,
+                 x: float, y: float, width: float, height: float, **kwargs):
+        """
+        Initialize the excalidraw primitive
+        :param excal_type: type of the excalidraw primitive
+        :param default_config: default values
+        :param x: top left x
+        :param y: top left y
+        :param width: width
+        :param height: height
+        :param kwargs: additional config to override defaults
+        """
+        self.excal_type = excal_type
+        self.excal_id = str(uuid.uuid4())
+        self.excal_seed = random.randint(0, 100000)
+
+        self.x = x
+        self.y = y
+        self.width = width
+        self.height = height
+        self._groupIds = []
+        self.apply_recursive_groups = []
+
+        self.config = copy.deepcopy(default_config)
+        for key, value in kwargs.items():
+            if key not in self.config:
+                raise Exception(f"Unexpected key for shape {excal_type}: {key}")
+            self.config[key] = value
+
+    def export(self):
+        """ Convert the excalidraw primitive specifications to a dictionary """
+        export_dict = {'id': self.excal_id, 'type': self.excal_type, 'seed': self.excal_seed,
+                       'x': self.x, 'y': self.y, 'width': self.width, 'height': self.height,
+                       'groupIds': self._groupIds}
+        export_dict.update(self.config)
+        return export_dict
+
+    def add_to_group(self, group_id):
+        self._groupIds.append(group_id)
+        for elem in self.apply_recursive_groups:
+            elem.add_to_group(group_id)
+
+    @property
+    def center(self):
+        """ Return the center of the excalidraw primitive """
+        return [self.x + self.width / 2, self.y + self.height / 2]
+
+    def get_edge_midpoint(self, theta, padding=5):
+        # given angle theta measured from the positive x-axis, return the boundary mapped to the center of the edges
+        theta_lim = math.atan2(self.height, self.width)
+        if abs(theta) < theta_lim or abs(theta) > math.pi - theta_lim:
+            sign_indicator = (abs(theta) < math.pi / 2)
+            x = self.x + self.width * sign_indicator + \
+                padding * (-1 + 2 * sign_indicator)
+            y = self.y + (self.height / 2)
+        else:
+            sign_indicator = (theta > 0)
+            x = self.x + self.width / 2
+            y = self.y + self.height * sign_indicator + \
+                padding * (-1 + 2 * sign_indicator)
+        return [x, y]
+
+
+class Shape(ExcaliDrawPrimitive):
+    def __init__(self, shape: str, default_config, x, y, width, height, **kwargs):
+        """
+        Creates a rectangle, ellipse, or diamond
+        :param shape: "rectangle", "ellipse", "diamond"
+        :param default_config: default values
+        :param x: center x
+        :param y: center y
+        :param width: width
+        :param height: height
+        :param kwargs: additional config to override defaults
+        """
+
+        x -= width/2
+        y -= height/2
+
+        super().__init__(shape, default_config, x=x, y=y, width=width, height=height, **kwargs)
+
+#TODO - fix fonts
+class Text(ExcaliDrawPrimitive):
+    def __init__(self, text: str, default_config, x, y, **kwargs):
+        """
+        Creates text item, width and height set automatically
+        :param text: text
+        :param default_config: default values
+        :param x: center x
+        :param y: center y
+        :param kwargs: additional config to override defaults
+        """
+
+        super().__init__('text', default_config, x, y, 0, 0, **kwargs)
+        self.text = text
+
+        d = super().export()
+        _font_file = FONT_FAMILY[d['fontFamily']]
+        _font = ImageFont.truetype(_font_file, d['fontSize'])
+        left, top, right, bottom = _font.getbbox(self.text)
+
+        self.width = right - left
+        self.height = bottom - top
+        self.x -= self.width / 2
+        self.y -= self.height / 2
+
+    def export(self):
+        d = super().export()
+        d['text'] = self.text
+        return d
+
+class Line(ExcaliDrawPrimitive):
+    def __init__(self, excal_type, default_config, start_pt: tuple, end_pt: tuple, **kwargs):
+        """
+        Creates a line or arrow
+        :param excal_type: 'line' or 'arrow'
+        :param default_config: default values
+        :param start_pt: start pt | tuple[float, float]
+        :param end_pt: end pt | tuple[float, float]
+        :param kwargs: additional config to override defaults
+        """
+
+        start_x = start_pt[0]
+        start_y = start_pt[1]
+        end_x = end_pt[0]
+        end_y = end_pt[1]
+        width = abs(end_x - start_x)
+        height = abs(end_y - start_y)
+        self.points = [[0, 0], [end_x - start_x, end_y - start_y]]
+
+        super().__init__(excal_type, default_config, x=start_x, y=start_y, width=width, height=height, **kwargs)
+
+    def export(self):
+        d = super().export()
+        d['points'] = self.points
+        return d
+
+    def set_start_binding(self, element: ExcaliDrawPrimitive, padding=10):
+        """ Set binding in both the line as well as the element."""
+        self.config["startBinding"] = {
+            "elementId": element.excal_id,
+            "focus": 0,
+            "gap": padding
+        }
+        bound_e = element.config.get('boundElements', [])
+        bound_e.append({
+            "id": self.excal_id,
+            "type": self.excal_type
+        })
+        element.config['boundElements'] = bound_e
+
+    def set_end_binding(self, element, padding=10):
+        """ Set binding in both the line as well as the element."""
+        self.config["endBinding"] = {
+            "elementId": element.excal_id,
+            "focus": 0,
+            "gap": padding
+        }
+        bound_e = element.config.get('boundElements', [])
+        bound_e.append({
+            "id": self.excal_id,
+            "type": self.excal_type
+        })
+        element.config['boundElements'] = bound_e
+
+class Group(ExcaliDrawPrimitive):
+    def __init__(self, elems: list[ExcaliDrawPrimitive], first_is_group = False):
+        """
+        Create a group (a fake element for handling group logic)
+        :param elems: list of excalidraw objects to group
+        :param first_is_group: treat the first element of the list as representing the whole group
+        """
+        group_id = str(uuid.uuid4())
+
+        left_x = min([elem.x for elem in elems])
+        top_y = min([elem.y for elem in elems])
+        width = max([elem.x + elem.width - left_x for elem in elems])
+        height = max([elem.y + elem.height - top_y for elem in elems])
+
+        for elem in elems:
+            elem.add_to_group(group_id)
+
+        super().__init__('group', {}, left_x, top_y, width, height)
+        self.elems = elems
+
+        if first_is_group:
+            elems[0].apply_recursive_groups.extend(elems[1:])
+
+    def export(self):
+        raise Exception("Group should not be exported - a group was incorrectly added to sketch.")
+
+    def add_to_group(self, group_id):
+        for elem in self.elems:
+            elem.add_to_group(group_id)

Excalidraw_Interface/sketch_builder.py

@@ -0,0 +1,241 @@
+from Excalidraw_Interface import primitives, defaults
+import json
+import math
+import copy
+
+def none_to_empty_dict(x):
+    if x is None:
+        return {}
+    return x
+
+class SketchBuilder:
+    def __init__(self, **custom_defaults):
+        """
+        Create a sketch
+        :param custom_defaults: overrides normal defaults
+        """
+        self._draw_objs: list[primitives.ExcaliDrawPrimitive] = []
+
+        self.BOX_DEFAULTS = copy.deepcopy(defaults.BOX_DEFAULTS)
+
+        self.LINE_DEFAULTS = copy.deepcopy(defaults.BOX_DEFAULTS)
+        self.LINE_DEFAULTS.update(copy.deepcopy(defaults.LINE_DEFAULTS))
+
+        self.TEXT_DEFAULTS = copy.deepcopy(defaults.BOX_DEFAULTS)
+        self.TEXT_DEFAULTS.update(copy.deepcopy(defaults.TEXT_DEFAULTS))
+
+        for key, value in custom_defaults.items():
+            used = False
+
+            if key in self.BOX_DEFAULTS:
+                self.BOX_DEFAULTS[key] = value
+                used = True
+
+            if key in self.LINE_DEFAULTS:
+                self.BOX_DEFAULTS[key] = value
+                used = True
+
+            if key in self.TEXT_DEFAULTS:
+                self.BOX_DEFAULTS[key] = value
+                used = True
+
+            if not used:
+                raise Exception(f"Key <{key}> not used.")
+
+    def add_element(self, element: primitives.ExcaliDrawPrimitive):
+        self._draw_objs.append(element)
+        return element
+
+    def Rectangle(self, x: float, y: float, width: float = 100, height: float = 100, **kwargs):
+        """
+        Creates a rectangle
+        :param x: center x
+        :param y: center y
+        :param width: width
+        :param height: height
+        :param kwargs: additional config to override defaults
+        """
+        return self.add_element(primitives.Shape('rectangle', self.BOX_DEFAULTS, x, y, width, height, **kwargs))
+
+    def Diamond(self, x: float, y: float, width: float = 100, height: float = 100, **kwargs):
+        """
+        Creates a diamond
+        :param x: center x
+        :param y: center y
+        :param width: width
+        :param height: height
+        :param kwargs: additional config to override defaults
+        """
+        return self.add_element(primitives.Shape('diamond', self.BOX_DEFAULTS, x, y, width, height, **kwargs))
+
+    def Ellipse(self, x: float, y: float, width: float = 100, height: float = 100, **kwargs):
+        """
+        Creates a ellipse
+        :param x: center x
+        :param y: center y
+        :param width: width
+        :param height: height
+        :param kwargs: additional config to override defaults
+        """
+        return self.add_element(primitives.Shape('ellipse', self.BOX_DEFAULTS, x, y, width, height, **kwargs))
+
+    def Text(self, text: str, x: float, y: float, **kwargs):
+        """
+        Creates text item, width and height set automatically
+        :param text: text
+        :param x: center x
+        :param y: center y
+        :param kwargs: additional config to override defaults
+        """
+        return self.add_element(primitives.Text(text, self.TEXT_DEFAULTS, x, y, **kwargs))
+
+    def Line(self, start_pt: tuple, end_pt: tuple, **kwargs):
+        """
+        Creates a line
+        :param start_pt: start pt | tuple[float, float]
+        :param end_pt: end pt | tuple[float, float]
+        :param kwargs: additional config to override defaults
+        """
+        return self.add_element(primitives.Line('line', self.LINE_DEFAULTS, start_pt, end_pt, **kwargs))
+
+    def Arrow(self, start_pt: tuple, end_pt: tuple, **kwargs):
+        """
+        Creates an arrow
+        :param start_pt: start pt | tuple[float, float]
+        :param end_pt: end pt | tuple[float, float]
+        :param kwargs: additional config to override defaults
+        """
+        kwargs['endArrowhead'] = 'arrow'
+        arrow = primitives.Line('arrow', self.LINE_DEFAULTS, start_pt, end_pt, **kwargs)
+        self.add_element(arrow)
+        return arrow
+
+    def DoubleArrow(self, start_pt: tuple, end_pt: tuple, **kwargs):
+        """
+        Creates a bi-directional arrow
+        :param start_pt: start pt | tuple[float, float]
+        :param end_pt: end pt | tuple[float, float]
+        :param kwargs: additional config to override defaults
+        """
+        kwargs['startArrowhead'] = 'arrow'
+        return self.Arrow(start_pt, end_pt, **kwargs)
+
+    def export_to_file(self, save_path):
+        """Export the sketch to a excalidraw file."""
+        data = {
+            "type": "excalidraw",
+            "version": 1,
+            "source": "Excalidraw.py",
+            "elements": [],
+            "appState": {
+                "viewBackgroundColor": "#ffffff",
+                "gridSize": None,
+            }
+        }
+
+        for element in self._draw_objs:
+            json_obj = element.export()
+            data['elements'].append(json_obj)
+
+        if save_path.split(".")[-1] != "excalidraw":
+            save_path += ".excalidraw"
+
+        with open(save_path, "w") as file_reader:
+            json.dump(data, file_reader, indent=4)
+
+    def create_binding_arrows(self, start: primitives.ExcaliDrawPrimitive, end: primitives.ExcaliDrawPrimitive,
+                              arrow = None, padding:int=10, **kwargs):
+        """
+        Create a binding arrow between two elements.
+        :param start: primitives.ExcaliDrawPrimitives
+        :param end: primitives.ExcaliDrawPrimitives
+        :param arrow: self.Arrow or self.DoubleArrow
+        :param padding: defaults to 10
+        :param kwargs: passed to arrow
+        """
+
+        if arrow is None:
+            arrow = self.Arrow
+
+        center_start = start.center
+        center_end = end.center
+        dx = center_end[0] - center_start[0]
+        dy = center_end[1] - center_start[1]
+        theta = math.atan2(dy, dx)
+        theta = (theta + math.pi) % (2*math.pi) - math.pi
+        inverted_theta = theta % (2*math.pi) - math.pi
+        start_pt = start.get_edge_midpoint(theta, padding=padding)
+        end_pt = end.get_edge_midpoint(inverted_theta, padding=padding)
+
+        line = arrow(start_pt, end_pt, **kwargs)
+        line.set_start_binding(start, padding=padding)
+        line.set_end_binding(end, padding=padding)
+
+    def create_bounding_element(self, element: primitives.ExcaliDrawPrimitive, function = None, padding = 10, **kwargs):
+        """
+        Create a bounding box around the given element/group.
+
+        :param element: primitives.ExcaliDrawPrimitives
+        :param function: self.Rectangle or similar, defaults to self.Rectangle
+        :param padding: defaults to 10
+        :param kwargs: passed to arrow
+        """
+
+        if function is None:
+            function = self.Rectangle
+
+        element_center = element.center
+        new_x = element_center[0]
+        new_y = element_center[1]
+
+        new_width = element.width + 2 * padding
+        new_height = element.height + 2 * padding
+
+        bounding_elem = function(x=new_x, y=new_y, width=new_width, height=new_height, **kwargs)
+        primitives.Group([bounding_elem, element], first_is_group=True)
+
+        return bounding_elem
+
+    def TextBox(self, text: str, x: float, y: float, txt_kwargs = None, rect_kwargs = None):
+        """
+        Creates a text box
+        :param text: text
+        :param x: center x
+        :param y: center y
+        :param txt_kwargs: other properties for text
+        :param rect_kwargs: other properties for rect
+        """
+        txt_kwargs = none_to_empty_dict(txt_kwargs)
+        rect_kwargs = none_to_empty_dict(rect_kwargs)
+
+        txt = self.Text(text, x, y, **txt_kwargs)
+        return self.create_bounding_element(txt, self.Rectangle, **rect_kwargs)
+
+    def HeaderContentBox(self, header: str, content: str, x: float, y: float, padding = 10,
+                         header_kwargs = None, content_kwargs = None, rect_kwargs = None):
+        """
+        Creates a multiline text box
+        :param header: text
+        :param content: text
+        :param x: center x
+        :param y: center y
+        :param padding: defaults to 10
+        :param header_kwargs: other properties for text
+        :param content_kwargs: other properties for text
+        :param rect_kwargs: other properties for rect
+        """
+        header_kwargs = none_to_empty_dict(header_kwargs)
+        content_kwargs = none_to_empty_dict(content_kwargs)
+        rect_kwargs = none_to_empty_dict(rect_kwargs)
+
+        fontSize = int(self.TEXT_DEFAULTS['fontSize'] * 2/3)
+
+        header_item = self.Text(header, x, y, **header_kwargs)
+        content_item = self.Text(content, x, y, fontSize=fontSize, **content_kwargs)
+        header_item.y -= header_item.height/2 + padding/2
+        content_item.y += content_item.height/2 + padding/2
+
+        return self.create_bounding_element(primitives.Group([header_item, content_item]),
+                                            self.Rectangle, **rect_kwargs)
+
+

Excalidraw_Interface-0.0.1.dist-info/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2024 Robert Nies
+
+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.

Excalidraw_Interface-0.0.1.dist-info/METADATA

@@ -0,0 +1,60 @@
+Metadata-Version: 2.1
+Name: Excalidraw_Interface
+Version: 0.0.1
+Summary: Create excalidraw drawings with python
+Home-page: https://github.com/RobertJN64/Excalidraw_Interface
+Author: Robert Nies
+Author-email: robertjnies@gmail.com
+License: MIT
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pillow
+
+# Excalidraw_Interface
+
+![Tests Badge](https://github.com/RobertJN64/Excalidraw_Interface/actions/workflows/tests.yml/badge.svg)
+![Python Version Badge](https://img.shields.io/pypi/pyversions/Excalidraw_Interface)
+![License Badge](https://img.shields.io/github/license/RobertJN64/Excalidraw_Interface)
+
+A pythonic interface for creating diagrams in Excalidraw.
+
+Based on https://github.com/BardOfCodes/procXD by Aditya Ganeshan (MIT License) and updated with modern python support
+and API improvements.
+
+## Example: Flowchart
+
+[flowchart.py](Excalidraw_Interface/examples/flowchart.py)
+
+![flowchart image](images/flowchart.png)
+
+```python
+from Excalidraw_Interface import SketchBuilder
+
+flowchart_items = ['First Step', 'Second Step', 'Third Step']
+
+sb = SketchBuilder() # Create a Sketch
+
+prev_item = sb.TextBox("Start Here", x = 0, y = 0) # Create a Text Box
+for index, item in enumerate(flowchart_items):
+    new_item = sb.TextBox(item, x = 0, y = (index+1) * 150) # Create a Text Box
+    sb.create_binding_arrows(prev_item, new_item) # Create arrows between boxes
+    prev_item = new_item
+
+hcb = sb.HeaderContentBox("Header", "Content", x = -200, y = 400) # Create a multiline text box
+circle = sb.Ellipse(200, 400, width=50, height=50, backgroundColor = 'red',
+                    roughness=1) # Create a red circle in hand drawn style
+
+sb.create_binding_arrows(prev_item, hcb, sb.DoubleArrow) # Create a double headed arrow
+sb.create_binding_arrows(prev_item, circle, strokeColor = 'blue') # Create an blue arrow
+
+sb.export_to_file('out.excalidraw')
+```

Excalidraw_Interface-0.0.1.dist-info/RECORD

@@ -0,0 +1,15 @@
+Excalidraw_Interface/LICENSE,sha256=vYmfhy4gf2coErkxHSgUP7zb6WENqyG41dsyYIujqtE,1091
+Excalidraw_Interface/__init__.py,sha256=l22sr6eOlpP_npl_bmQVPoWRiF5YEzdMAs2TmW4sgks,211
+Excalidraw_Interface/defaults.py,sha256=QoRj79j0d_P1ibTlBHuhkKsC_sSPQTnAYwQP4v8kCa0,1242
+Excalidraw_Interface/primitives.py,sha256=uFqVRkpvvH7rBDW5l7hZdFolOEYFpD4_q7ISKvsGWXA,7287
+Excalidraw_Interface/sketch_builder.py,sha256=zoa9iP06utfqBRvCnv2ZOQZQTElql5844mxDDLCWjU4,8878
+Excalidraw_Interface/examples/advanced_groups.py,sha256=diQqtt89FvN-MOLFm0-nirv00nGRC1b1VwTg9XemE0Y,443
+Excalidraw_Interface/examples/flowchart.py,sha256=rEHzX-pCx48mY8msKjpiZiwE-EGowxlYqzPhnaCaDUE,916
+Excalidraw_Interface/fonts/Assistant-VariableFont.ttf,sha256=zXRaFBMUUNiaDC8P4RtWeZpV1prWpIsvWexaf_I34m0,79660
+Excalidraw_Interface/fonts/CascadiaCode.ttf,sha256=bMImJUcgotsFnWr0s_37IR6k8JQNzuscb_UsWpSinzs,648732
+Excalidraw_Interface/fonts/Virgil.ttf,sha256=VvZN1QlKTwyUk7R7U4NMQgXvv9bAljLOfEj32qh1v1k,80720
+Excalidraw_Interface-0.0.1.dist-info/LICENSE,sha256=KHnSJvDPomXIpSt5dhDeRVUkjv2pX-igPsphn1sPDyI,1054
+Excalidraw_Interface-0.0.1.dist-info/METADATA,sha256=PJxWaOSWyOCRNl9tNZQzeU7N9kBYrjq41CRhfZebolk,2311
+Excalidraw_Interface-0.0.1.dist-info/WHEEL,sha256=Mdi9PDNwEZptOjTlUcAth7XJDFtKrHYaQMPulZeBCiQ,91
+Excalidraw_Interface-0.0.1.dist-info/top_level.txt,sha256=XCwxnUO1EE0YkS-IVQpi8D320gGVWWcDbh3TDCqzkTs,21
+Excalidraw_Interface-0.0.1.dist-info/RECORD,,

Excalidraw_Interface-0.0.1.dist-info/WHEEL

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

Excalidraw_Interface-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+Excalidraw_Interface