brushcue

151class Project:
152    """A Python façade for a Rust graph project."""
153
154    def __init__(self, inner: _internal.Project | None = None):
155        self._inner = _internal.Project() if inner is None else inner
156
157    def add_graph(self, graph: _GraphWrapper | _internal.Graph) -> Project:
158        return Project(self._inner.add_graph(unwrap_graph(graph)))
159
160    def execute(self, context: _internal.Context, graph_id: int) -> _internal.Type:
161        return self._inner.execute(context, graph_id)

 9def brushcue_fn(fn):
10    @wraps(fn)
11    def wrapper(*args, **kwargs):
12        return fn(*args, **kwargs)
13
14    def brushcue_make_graph(
15            type_definitions: list[brushcue.TypeDefinition],
16    ):
17        inputs = [
18            brushcue.Object.input(type_definition)
19            for type_definition in type_definitions
20        ]
21        output = fn(*inputs)
22        wrapper.__brushcue_output_graph__ = output
23        return *(unwrap_graph(graph) for graph in inputs), unwrap_graph(output)
24
25    wrapper.__brushcue_make_graph__ = brushcue_make_graph
26    return wrapper

22def float_list_empty() -> FloatList:
23    result = _internal.float_list_empty_internal()
24    from .float_list import FloatList
25    return FloatList(result)

28def int_list_empty() -> IntList:
29    result = _internal.int_list_empty_internal()
30    from .int_list import IntList
31    return IntList(result)

34def null_value() -> Null:
35    result = _internal.null_value_internal()
36    from .null import Null
37    return Null(result)

40def point2f_list_empty() -> Point2fList:
41    result = _internal.point2f_list_empty_internal()
42    from .point2f_list import Point2fList
43    return Point2fList(result)

46def point2i_list_empty() -> Point2iList:
47    result = _internal.point2i_list_empty_internal()
48    from .point2i_list import Point2iList
49    return Point2iList(result)

52def string_list_empty() -> StringList:
53    result = _internal.string_list_empty_internal()
54    from .string_list import StringList
55    return StringList(result)

17class Bool(Object):
18    """A bool"""
19
20    def execute(self, context):
21        return self._inner.execute(context).as_bool()
22
23    if TYPE_CHECKING:
24        # Implemented at runtime via monkeypatching in `_operators.py`; declared
25        # here only so static type checkers recognize these operators.
26        def __and__(self, other: Bool | builtins.bool) -> Bool: ...
27        def __rand__(self, other: Bool | builtins.bool) -> Bool: ...
28        def __or__(self, other: Bool | builtins.bool) -> Bool: ...
29        def __ror__(self, other: Bool | builtins.bool) -> Bool: ...
30        def __xor__(self, other: Bool | builtins.bool) -> Bool: ...
31        def __rxor__(self, other: Bool | builtins.bool) -> Bool: ...
32        def __invert__(self) -> Bool: ...
33
34    def and_(self, bool2) -> Bool:
35        """And
36
37        Returns true if both inputs are true.
38
39        Args:
40            bool2: Graph of Bool
41
42        Returns:
43            Graph: A graph node producing a Bool.
44        """
45        bool1_parsed = input_parsers.parse_bool_graph(self)
46        bool2_parsed = input_parsers.parse_bool_graph(bool2)
47        result = _internal.and_internal(bool1_parsed, bool2_parsed)
48        return Bool(result)
49
50    def not_(self) -> Bool:
51        """Not
52
53        Returns the opposite of a boolean
54
55        Returns:
56            Graph: A graph node producing a Bool.
57        """
58        bool_parsed = input_parsers.parse_bool_graph(self)
59        result = _internal.not_internal(bool_parsed)
60        return Bool(result)
61
62    def or_(self, bool2) -> Bool:
63        """Or
64
65        Returns true if either inputs are true.
66
67        Args:
68            bool2: Graph of Bool
69
70        Returns:
71            Graph: A graph node producing a Bool.
72        """
73        bool1_parsed = input_parsers.parse_bool_graph(self)
74        bool2_parsed = input_parsers.parse_bool_graph(bool2)
75        result = _internal.or_internal(bool1_parsed, bool2_parsed)
76        return Bool(result)
77
78    def xor(self, bool2) -> Bool:
79        """Exclusive Or
80
81        Returns true if either the inputs are true. But false if both are true.
82
83        Args:
84            bool2: Graph of Bool
85
86        Returns:
87            Graph: A graph node producing a Bool.
88        """
89        bool1_parsed = input_parsers.parse_bool_graph(self)
90        bool2_parsed = input_parsers.parse_bool_graph(bool2)
91        result = _internal.xor_internal(bool1_parsed, bool2_parsed)
92        return Bool(result)

17class Bounds2f(Object):
18    """A 2D bounding box of Floats"""
19
20    def execute(self, context):
21        return self._inner.execute(context).as_bounds2f()
22
23    @staticmethod
24    def from_x_y_width_height(x, y, width, height) -> Bounds2f:
25        """Bounds 2D Float from X, Y, Width & Height
26
27        Creates the bounds of a 2D float region from its X, Y, Width and Height.
28
29        Args:
30            x: Graph of Float
31            y: Graph of Float
32            width: Graph of Float
33            height: Graph of Float
34
35        Returns:
36            Graph: A graph node producing a Bounds2f.
37        """
38        x_parsed = input_parsers.parse_float_graph(x)
39        y_parsed = input_parsers.parse_float_graph(y)
40        width_parsed = input_parsers.parse_float_graph(width)
41        height_parsed = input_parsers.parse_float_graph(height)
42        result = _internal.bounds2f_from_x_y_width_height_internal(x_parsed, y_parsed, width_parsed, height_parsed)
43        return Bounds2f(result)
44
45    def height(self) -> float.Float:
46        """Bounds2f Height
47
48        Gets the height of the bounds.
49
50        Returns:
51            Graph: A graph node producing a Float.
52        """
53        bounds_parsed = input_parsers.parse_graph(self)
54        result = _internal.bounds2f_height_internal(bounds_parsed)
55        from .float import Float
56        return Float(result)
57
58    def min_x(self) -> float.Float:
59        """Bounds2f Min X
60
61        Gets the minimum X coordinate (left edge) of the bounds.
62
63        Returns:
64            Graph: A graph node producing a Float.
65        """
66        bounds_parsed = input_parsers.parse_graph(self)
67        result = _internal.bounds2f_min_x_internal(bounds_parsed)
68        from .float import Float
69        return Float(result)
70
71    def min_y(self) -> float.Float:
72        """Bounds2f Min Y
73
74        Gets the minimum Y coordinate (top edge) of the bounds.
75
76        Returns:
77            Graph: A graph node producing a Float.
78        """
79        bounds_parsed = input_parsers.parse_graph(self)
80        result = _internal.bounds2f_min_y_internal(bounds_parsed)
81        from .float import Float
82        return Float(result)
83
84    def width(self) -> float.Float:
85        """Bounds2f Width
86
87        Gets the width of the bounds.
88
89        Returns:
90            Graph: A graph node producing a Float.
91        """
92        bounds_parsed = input_parsers.parse_graph(self)
93        result = _internal.bounds2f_width_internal(bounds_parsed)
94        from .float import Float
95        return Float(result)

11class Bounds2fList(List):
12    """List of Bounds 2D Floats"""
13
14    def __init__(self, inner, resolved_type=None):
15        from .bounds2f import Bounds2f
16        super().__init__(inner, Bounds2f if resolved_type is None else resolved_type)
17
18    def execute(self, context):
19        return self._inner.execute(context)

12class Bounds2i(Object):
13    """A 2D bounding box of Ints"""
14
15    def execute(self, context):
16        return self._inner.execute(context)
17
18    @staticmethod
19    def from_x_y_width_height(x, y, width, height) -> Bounds2i:
20        """Bounds 2D Int from X, Y, Width & Height
21
22        Creates the bounds of a 2D array from its X, Y, Width and Height.
23
24        Args:
25            x: Graph of Int
26            y: Graph of Int
27            width: Graph of Int
28            height: Graph of Int
29
30        Returns:
31            Graph: A graph node producing a Bounds2i.
32        """
33        x_parsed = input_parsers.parse_int_graph(x)
34        y_parsed = input_parsers.parse_int_graph(y)
35        width_parsed = input_parsers.parse_int_graph(width)
36        height_parsed = input_parsers.parse_int_graph(height)
37        result = _internal.bounds2i_from_x_y_width_height_internal(x_parsed, y_parsed, width_parsed, height_parsed)
38        return Bounds2i(result)

11class Bounds2iList(List):
12    """List of Bounds 2D Ints"""
13
14    def __init__(self, inner, resolved_type=None):
15        from .bounds2i import Bounds2i
16        super().__init__(inner, Bounds2i if resolved_type is None else resolved_type)
17
18    def execute(self, context):
19        return self._inner.execute(context)

12class Brush(Object):
13    """A brush to stroke on 2D objects"""
14
15    def execute(self, context):
16        return self._inner.execute(context)
17
18    @staticmethod
19    def custom(function_body, helpers, inputs, radius) -> Brush:
20        """Brush Custom
21
22        Creates a brush with a custom shader.
23
24        Args:
25            function_body: Graph of String
26            helpers: Graph of String
27            inputs: Graph of Dictionary
28            radius: Graph of Float
29
30        Returns:
31            Graph: A graph node producing a Brush.
32        """
33        function_body_parsed = input_parsers.parse_string_graph(function_body)
34        helpers_parsed = input_parsers.parse_string_graph(helpers)
35        inputs_parsed = input_parsers.parse_graph(inputs)
36        radius_parsed = input_parsers.parse_float_graph(radius)
37        result = _internal.brush_custom_internal(function_body_parsed, helpers_parsed, inputs_parsed, radius_parsed)
38        return Brush(result)
39
40    @staticmethod
41    def dashed(color_1, color_1_length, color_2, color_2_length, radius) -> Brush:
42        """Brush Dashed
43
44        Creates a brush that alternates between two colors along the length of the path, for dashed/dotted strokes.
45
46        Args:
47            color_1: Graph of ProfiledColor
48            color_1_length: Graph of Float
49            color_2: Graph of ProfiledColor
50            color_2_length: Graph of Float
51            radius: Graph of Float
52
53        Returns:
54            Graph: A graph node producing a Brush.
55        """
56        color_1_parsed = input_parsers.parse_graph(color_1)
57        color_1_length_parsed = input_parsers.parse_float_graph(color_1_length)
58        color_2_parsed = input_parsers.parse_graph(color_2)
59        color_2_length_parsed = input_parsers.parse_float_graph(color_2_length)
60        radius_parsed = input_parsers.parse_float_graph(radius)
61        result = _internal.brush_dashed_internal(color_1_parsed, color_1_length_parsed, color_2_parsed, color_2_length_parsed, radius_parsed)
62        return Brush(result)
63
64    @staticmethod
65    def solid(color, radius) -> Brush:
66        """Brush Solid
67
68        Creates a brush with a color and radius. Will stroke with the solid color.
69
70        Args:
71            color: Graph of ProfiledColor
72            radius: Graph of Float
73
74        Returns:
75            Graph: A graph node producing a Brush.
76        """
77        color_parsed = input_parsers.parse_graph(color)
78        radius_parsed = input_parsers.parse_float_graph(radius)
79        result = _internal.brush_solid_internal(color_parsed, radius_parsed)
80        return Brush(result)

 18class Bytes(Object):
 19    """A list of bytes"""
 20
 21    def execute(self, context):
 22        return self._inner.execute(context)
 23
 24    @staticmethod
 25    def from_url(url) -> Bytes:
 26        """Bytes from URL
 27
 28        Given a URL. Performs a GET request and downloads the result as bytes.
 29
 30        Args:
 31            url: Graph of String
 32
 33        Returns:
 34            Graph: A graph node producing a Bytes.
 35        """
 36        url_parsed = input_parsers.parse_string_graph(url)
 37        result = _internal.bytes_from_u_r_l_internal(url_parsed)
 38        return Bytes(result)
 39
 40    def save_to_path(self, path) -> string.String:
 41        """Bytes Save to Path
 42
 43        Writes a byte list to a specified file path on disk. Returns the path that was written to.
 44
 45        Args:
 46            path: Graph of String
 47
 48        Returns:
 49            Graph: A graph node producing a String.
 50        """
 51        bytes_parsed = input_parsers.parse_graph(self)
 52        path_parsed = input_parsers.parse_string_graph(path)
 53        result = _internal.bytes_save_to_path_internal(bytes_parsed, path_parsed)
 54        from .string import String
 55        return String(result)
 56
 57    def file_convert_image_to_bmp(self) -> Bytes:
 58        """File Convert Image to BMP
 59
 60        Converts any image format (JPEG, PNG, WebP, TIFF, HEIC, etc.) to BMP. Returns BMP bytes.
 61
 62        Returns:
 63            Graph: A graph node producing a Bytes.
 64        """
 65        image_bytes_parsed = input_parsers.parse_graph(self)
 66        result = _internal.file_convert_image_to_bmp_internal(image_bytes_parsed)
 67        return Bytes(result)
 68
 69    def file_convert_image_to_heic(self, quality) -> Bytes:
 70        """File Convert Image to HEIC
 71
 72        Converts any image format (JPEG, PNG, WebP, TIFF, BMP, etc.) to HEIC. Returns HEIC bytes.
 73
 74        Args:
 75            quality: Graph of Int
 76
 77        Returns:
 78            Graph: A graph node producing a Bytes.
 79        """
 80        image_bytes_parsed = input_parsers.parse_graph(self)
 81        quality_parsed = input_parsers.parse_int_graph(quality)
 82        result = _internal.file_convert_image_to_heic_internal(image_bytes_parsed, quality_parsed)
 83        return Bytes(result)
 84
 85    def file_convert_image_to_jpeg(self, quality) -> Bytes:
 86        """File Convert Image to JPEG
 87
 88        Converts any image format (PNG, WebP, TIFF, BMP, HEIC, etc.) to JPEG. Returns JPEG bytes.
 89
 90        Args:
 91            quality: Graph of Int
 92
 93        Returns:
 94            Graph: A graph node producing a Bytes.
 95        """
 96        image_bytes_parsed = input_parsers.parse_graph(self)
 97        quality_parsed = input_parsers.parse_int_graph(quality)
 98        result = _internal.file_convert_image_to_jpeg_internal(image_bytes_parsed, quality_parsed)
 99        return Bytes(result)
100
101    def file_convert_image_to_png(self) -> Bytes:
102        """File Convert Image to PNG
103
104        Converts any image format (JPEG, WebP, TIFF, BMP, HEIC, etc.) to PNG. Returns PNG bytes.
105
106        Returns:
107            Graph: A graph node producing a Bytes.
108        """
109        image_bytes_parsed = input_parsers.parse_graph(self)
110        result = _internal.file_convert_image_to_png_internal(image_bytes_parsed)
111        return Bytes(result)
112
113    def file_convert_image_to_tiff(self) -> Bytes:
114        """File Convert Image to TIFF
115
116        Converts any image format (JPEG, PNG, WebP, BMP, HEIC, etc.) to TIFF. Returns TIFF bytes.
117
118        Returns:
119            Graph: A graph node producing a Bytes.
120        """
121        image_bytes_parsed = input_parsers.parse_graph(self)
122        result = _internal.file_convert_image_to_tiff_internal(image_bytes_parsed)
123        return Bytes(result)
124
125    def file_convert_image_to_web_p(self, quality) -> Bytes:
126        """File Convert Image to WebP
127
128        Converts any image format (JPEG, PNG, TIFF, BMP, HEIC, etc.) to WebP. Returns WebP bytes.
129
130        Args:
131            quality: Graph of Int
132
133        Returns:
134            Graph: A graph node producing a Bytes.
135        """
136        image_bytes_parsed = input_parsers.parse_graph(self)
137        quality_parsed = input_parsers.parse_int_graph(quality)
138        result = _internal.file_convert_image_to_web_p_internal(image_bytes_parsed, quality_parsed)
139        return Bytes(result)
140
141    def file_convert_video_to_gif(self, frame_rate) -> Bytes:
142        """File Convert Video to GIF
143
144        Converts any video format (MP4, MOV, WebM, AVI, MKV) to a GIF. Returns GIF bytes.
145
146        Args:
147            frame_rate: Graph of Int
148
149        Returns:
150            Graph: A graph node producing a Bytes.
151        """
152        video_bytes_parsed = input_parsers.parse_graph(self)
153        frame_rate_parsed = input_parsers.parse_int_graph(frame_rate)
154        result = _internal.file_convert_video_to_gif_internal(video_bytes_parsed, frame_rate_parsed)
155        return Bytes(result)
156
157    def file_convert_video_to_mp4(self) -> Bytes:
158        """File Convert Video to MP4
159
160        Converts any video format (MOV, WebM, AVI, MKV) to MP4. Returns MP4 bytes.
161
162        Returns:
163            Graph: A graph node producing a Bytes.
164        """
165        video_bytes_parsed = input_parsers.parse_graph(self)
166        result = _internal.file_convert_video_to_m_p4_internal(video_bytes_parsed)
167        return Bytes(result)
168
169    def file_convert_video_to_web_m(self) -> Bytes:
170        """File Convert Video to WebM
171
172        Converts any video format (MP4, MOV, AVI, MKV) to WebM. Returns WebM bytes.
173
174        Returns:
175            Graph: A graph node producing a Bytes.
176        """
177        video_bytes_parsed = input_parsers.parse_graph(self)
178        result = _internal.file_convert_video_to_web_m_internal(video_bytes_parsed)
179        return Bytes(result)
180
181    def upload_bytes(self, url, content_type) -> void.Void:
182        """Upload Bytes
183
184        Given bytes and a URL. Performs a PUT request and uploads the bytes
185
186        Args:
187            url: Graph of String
188            content_type: Graph of String
189
190        Returns:
191            Graph: A graph node producing a Void.
192        """
193        bytes_parsed = input_parsers.parse_graph(self)
194        url_parsed = input_parsers.parse_string_graph(url)
195        content_type_parsed = input_parsers.parse_string_graph(content_type)
196        result = _internal.upload_bytes_internal(bytes_parsed, url_parsed, content_type_parsed)
197        from .void import Void
198        return Void(result)