Merge branch 'v3-dev' into dogukan/cnx-1422-rendermaterial-and-colorproxy

updated_at time for Model search

.gitignore

@@ -13,4 +13,5 @@ Installers/
 modules/
 .tool-versions
 requirements.txt
-SEMVER
+SEMVER
+dui3/

README.md

@@ -83,7 +83,7 @@ The full matrix of supported Blender and Speckle types [can be found here](https
 ## Dependency Installation and Compatibility with Other Blender Addons
 
 Upon first launch of the addon, the Speckle connector installs its SpecklePy dependencies in `%appdata%/Speckle/connector_installations` on Windows and `~/.config/Speckle/connector_installations` on Mac.
-This is done through our [`installer.py`](https://github.com/specklesystems/speckle-blender/blob/main/bpy_speckle/installer.py). Through pip, we install the correct version of each dependency for your blender python version, host OS, and system architecture.
+This is done through our [`installer.py`](https://github.com/specklesystems/speckle-blender/blob/main/bpy_speckle/installer.py). Through uv, we install the correct version of each dependency for your blender python version, host OS, and system architecture.
 As such, an internet connection is required for first launch of the connector.
 
 Other blender addons may require dependencies that conflict with specklepy. In these cases, one or both addons may fail to load.

bpy_speckle/__init__.py

@@ -1,113 +1,95 @@
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTIBILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+# ruff: noqa
 import bpy
-from bpy_speckle.installer import ensure_dependencies
+from bpy.props import PointerProperty, CollectionProperty, StringProperty, IntProperty, IntVectorProperty
+from .connector.ui import icons
+import json
 
+# Ensure dependencies
+from .installer import ensure_dependencies
 ensure_dependencies(f"Blender {bpy.app.version[0]}.{bpy.app.version[1]}")
 
-from specklepy.logging import metrics
 
-from bpy_speckle.ui import *
-from bpy_speckle.properties import *
-from bpy_speckle.operators import *
-from bpy_speckle.callbacks import *
-from bpy.app.handlers import persistent
+# UI
+from .connector.ui.main_panel import SPECKLE_PT_main_panel
+from .connector.ui.project_selection_dialog import SPECKLE_OT_project_selection_dialog, speckle_project, SPECKLE_UL_projects_list, SPECKLE_OT_add_project_by_url
+from .connector.ui.model_selection_dialog import SPECKLE_OT_model_selection_dialog, speckle_model, SPECKLE_UL_models_list
+from .connector.ui.version_selection_dialog import SPECKLE_OT_version_selection_dialog, speckle_version, SPECKLE_UL_versions_list
+from .connector.ui.selection_filter_dialog import SPECKLE_OT_selection_filter_dialog
+from .connector.ui.model_card import speckle_model_card
+# Operators
+from .connector.blender_operators.publish_button import SPECKLE_OT_publish
+from .connector.blender_operators.load_button import SPECKLE_OT_load
+from .connector.blender_operators.model_card_settings import SPECKLE_OT_model_card_settings, SPECKLE_OT_view_in_browser, SPECKLE_OT_view_model_versions
+from .connector.blender_operators.select_objects import SPECKLE_OT_select_objects
 
-bl_info = {
-    "name": "SpeckleBlender 2.0",
-    "author": "Speckle Systems",
-    "version": (0, 2, 0),
-    "blender": (2, 92, 0),
-    "location": "3d viewport toolbar (N), under the Speckle tab.",
-    "description": "The Speckle Connector using specklepy 2.0!",
-    "warning": "This add-on is WIP and should be used with caution",
-    "wiki_url": "https://github.com/specklesystems/speckle-blender",
-    "category": "Scene",
-}
+# States
+from .connector.states.speckle_state import register as register_speckle_state, unregister as unregister_speckle_state
+
+def save_model_cards(scene):
+    model_cards_data = [card.to_dict() for card in scene.speckle_state.model_cards]
+    scene["speckle_model_cards_data"] = json.dumps(model_cards_data)
+
+def load_model_cards(scene):
+    if "speckle_model_cards_data" in scene:
+        model_cards_data = json.loads(scene["speckle_model_cards_data"])
+        scene.speckle_state.model_cards.clear()
+        for card_data in model_cards_data:
+            card = speckle_model_card.from_dict(card_data)
+            scene.speckle_state.model_cards.add().update(card)
 
 
+# Classes to load
+classes = (
+    SPECKLE_PT_main_panel,
+    SPECKLE_OT_publish,
+    SPECKLE_OT_load,
+    SPECKLE_OT_project_selection_dialog, speckle_project, SPECKLE_UL_projects_list, SPECKLE_OT_add_project_by_url,
+    SPECKLE_OT_model_selection_dialog, speckle_model, SPECKLE_UL_models_list,
+    SPECKLE_OT_version_selection_dialog, speckle_version, SPECKLE_UL_versions_list,
+    SPECKLE_OT_selection_filter_dialog,
+    speckle_model_card, SPECKLE_OT_model_card_settings, SPECKLE_OT_view_in_browser, SPECKLE_OT_view_model_versions,
+    SPECKLE_OT_select_objects)
 
-"""
-Import SpeckleBlender classes
-"""
-
-"""
-Add load handler to initialize Speckle when 
-loading a Blender file
-"""
-
-@persistent
+@bpy.app.handlers.persistent
 def load_handler(dummy):
-    pass
-    # Calling users_load is an expensive operation, one that force users to wait a good 10s every time blender loads.
-    # Until we can do this non-blocking, we will make the user hit the refresh button each time.
-    #bpy.ops.speckle.users_load()
-    
-    # Instead, we shall just reset the user selection to an uninitiailised state
-    bpy.ops.speckle.users_reset()
-
-"""
-Permanent handle on callbacks
-"""
-
-callbacks = {}
-
-"""
-Add Speckle classes for registering
-"""
-
-speckle_classes = []
-speckle_classes.extend(operator_classes)
-speckle_classes.extend(property_classes)
-speckle_classes.extend(ui_classes)
+    load_model_cards(bpy.context.scene)
 
+@bpy.app.handlers.persistent
+def save_handler(dummy):
+    save_model_cards(bpy.context.scene)
 
+# Register and Unregister
 def register():
-    from bpy.utils import register_class
+    icons.load_icons()
 
-    for cls in speckle_classes:
-        register_class(cls)
-
-    metrics.set_host_app("blender", f"blender {bpy.app.version_string}")
-
-    """
-    Register all new properties
-    """
-
-    bpy.types.Scene.speckle = bpy.props.PointerProperty(type=SpeckleSceneSettings)
-    bpy.types.Collection.speckle = bpy.props.PointerProperty(
-        type=SpeckleCollectionSettings
-    )
-    bpy.types.Object.speckle = bpy.props.PointerProperty(type=SpeckleObjectSettings)
-
-    """
-    Add callbacks
-    """
-
-    # Callback for displaying the current user account on top of the 3d view
-    # callbacks['view3d_status'] = ((
-    #     bpy.types.SpaceView3D.draw_handler_remove, # Function pointer for removal
-    #     bpy.types.SpaceView3D.draw_handler_add(draw_speckle_info, (None, None), 'WINDOW', 'POST_PIXEL'), # Add handler
-    #     'WINDOW' # Callback space for removal
-    #     ))
+    for cls in classes:
+        bpy.utils.register_class(cls)
+    register_speckle_state() # Register SpeckleState
 
     bpy.app.handlers.load_post.append(load_handler)
-
+    bpy.app.handlers.save_post.append(save_handler)
 
 def unregister():
+    icons.unload_icons()
+    unregister_speckle_state() # Unregister SpeckleState
+    for cls in classes:
+        bpy.utils.unregister_class(cls)
 
     bpy.app.handlers.load_post.remove(load_handler)
+    bpy.app.handlers.save_post.remove(save_handler)
 
-    """
-    Remove callbacks
-    """
-
-    for cb in callbacks.values():
-        cb[0](cb[1], cb[2])
-
-    from bpy.utils import unregister_class
-
-    for cls in reversed(speckle_classes):
-        unregister_class(cls)
-
-
+# Run the register function when the script is executed
 if __name__ == "__main__":
     register()

bpy_speckle/blender_commit_object_builder.py

@@ -1,120 +0,0 @@
-from typing import Dict, Optional, Tuple, Union
-import bpy
-from bpy.types import Object, Collection, ID
-from specklepy.objects.base import Base
-from bpy_speckle.functions import _report
-from specklepy.objects.graph_traversal.commit_object_builder import CommitObjectBuilder, ROOT
-from specklepy.objects import Base
-from specklepy.objects.other import Collection as SCollection
-from attrs import define
-
-ELEMENTS = "elements"
-
-def _id(native_object: ID) -> str:
-    #NOTE: to avoid naming collisions, we prefix collections and objects differently
-    return f"{type(native_object).__name__}:{native_object.name_full}" 
-
-def _try_id(native_object: Optional[Union[Collection, Object]]) -> Optional[str]:
-    return _id(native_object) if native_object else None
-
-def convert_collection_to_speckle(col: Collection) -> SCollection:
-    converted_collection = SCollection(name = col.name_full, collectionType = "Blender Collection", elements = [])
-    converted_collection.applicationId = _id(col)
-
-    color_tag = col.color_tag
-    if color_tag and color_tag != "NONE":
-        converted_collection["colorTag"] = col.color_tag
-
-    return converted_collection
-
-@define(slots=True)
-class BlenderCommitObjectBuilder(CommitObjectBuilder[Object]):
-
-    _collections: Dict[str, SCollection]
-
-    def __init__(self) -> None:
-        super().__init__()
-        self._collections = {}
-
-    def include_object(self, conversion_result: Base, native_object: Object) -> None:
-
-        # Set the Child -> Parent relationships
-        parent = native_object.parent
-        
-        parent_collections = native_object.users_collection 
-        parent_collection = parent_collections[0] if len(parent_collections) > 0 else None #NOTE: we don't support objects appearing in more than one collection, for now, we will just take the zeroth one
-        
-        app_id = _id(native_object)
-        conversion_result.applicationId = app_id
-        self.converted[app_id] = conversion_result
-
-        # in order or priority, direct parent, direct parent collection, root
-        self.set_relationship(app_id, (_try_id(parent), ELEMENTS), (_try_id(parent_collection), ELEMENTS), (ROOT, ELEMENTS))
-        # if parent_collection:
-        #     self._include_collection(parent_collection)
-
-    def ensure_collection(self, col: Collection) -> SCollection:
-        id = _id(col)
-        if id in self._collections:
-            return self._collections[id] # collection already converted!
-
-         # Set the Parent -> Children relationships
-        for c in col.children:
-            #NOTE: There's no falling back to the grandparent, if the direct parent collection wasn't converted, then we we fallback to the root
-            self.set_relationship(_id(c), (id, ELEMENTS), (ROOT, ELEMENTS)) 
-
-        # Set Child -> Parent relationship
-        # parent = self.find_collection_parent(col)
-        # self.set_relationship(id, (_try_builder_id(parent), ELEMENTS), (ROOT, ELEMENTS)) 
-
-        converted_collection = convert_collection_to_speckle(col)
-        self.converted[id] = converted_collection
-        self._collections[id] = converted_collection
-
-        return converted_collection
-
-    def build_commit_object(self, root_commit_object: Base) -> None:
-        assert(root_commit_object.applicationId in self.converted)
-
-        # Create all collections
-        root_col = self.ensure_collection(bpy.context.scene.collection)
-        root_col.collectionType = "Scene Collection"
-        for col in bpy.context.scene.collection.children_recursive:
-            self.ensure_collection(col)
-
-        objects_to_build = set(self.converted.values())
-        objects_to_build.remove(root_commit_object)
-
-        self.apply_relationships(objects_to_build, root_commit_object)
-
-        assert(isinstance(root_commit_object, SCollection))
-        # Kill unused collections
-
-        def should_remove_unuseful_collection(col: SCollection) -> bool: #TODO: this maybe could be optimised
-            elements = col.elements
-            if not elements: return True
-
-            should_remove_this_col = True
-
-            i = 0
-            while i < len(elements):
-                c = elements[i]
-                if not isinstance(c, SCollection): 
-                    # col has objects (c)
-                    should_remove_this_col = False
-                    i += 1
-                    continue
-
-                if should_remove_unuseful_collection(c):
-                    # c is not useful, kill it
-                    del elements[i]
-                else:
-                    # col has a child (c) with objects
-                    should_remove_this_col = False
-                    i += 1
-                    continue
-        
-            return should_remove_this_col
-
-        if should_remove_unuseful_collection(root_commit_object):
-            _report("WARNING: Only empty collections have been converted!") #TODO: consider raising exception here, to halt the send operation

bpy_speckle/blender_manifest.toml

@@ -0,0 +1,75 @@
+schema_version = "1.0.0"
+
+# Example of manifest file for a Blender extension
+# Change the values according to your extension
+id = "speckle_blender_addon"
+version = "3.0.0"
+name = "Speckle for Blender BETA"
+tagline = "Speckle connector for Blender"
+maintainer = "Speckle Systems"
+# Supported types: "add-on", "theme"
+type = "add-on"
+
+# Optional link to documentation, support, source files, etc
+website = "https://speckle.guide/user/blender.html"
+
+# Optional list defined by Blender and server, see:
+# https://docs.blender.org/manual/en/dev/advanced/extensions/tags.html
+tags = ["Scene"]
+
+blender_version_min = "4.2.0"
+# # Optional: Blender version that the extension does not support, earlier versions are supported.
+# # This can be omitted and defined later on the extensions platform if an issue is found.
+# blender_version_max = "5.1.0"
+
+# License conforming to https://spdx.org/licenses/ (use "SPDX: prefix)
+# https://docs.blender.org/manual/en/dev/advanced/extensions/licenses.html
+license = [
+  "SPDX:Apache-2.0",
+]
+# Optional: required by some licenses.
+# copyright = [
+#   "2002-2024 Developer Name",
+#   "1998 Company Name",
+# ]
+
+# Optional list of supported platforms. If omitted, the extension will be available in all operating systems.
+# platforms = ["windows-x64", "macos-arm64", "linux-x64"]
+# Other supported platforms: "windows-arm64", "macos-x64"
+
+# Optional: bundle 3rd party Python modules.
+# https://docs.blender.org/manual/en/dev/advanced/extensions/python_wheels.html
+# wheels = [
+#   "./wheels/hexdump-3.3-py3-none-any.whl",
+#   "./wheels/jsmin-3.0.1-py3-none-any.whl",
+# ]
+
+# Optional: add-ons can list which resources they will require:
+# * files (for access of any filesystem operations)
+# * network (for internet access)
+# * clipboard (to read and/or write the system clipboard)
+# * camera (to capture photos and videos)
+# * microphone (to capture audio)
+# permissions = ["network"]
+
+#
+# If using network, remember to also check `bpy.app.online_access`
+# https://docs.blender.org/manual/en/dev/advanced/extensions/addons.html#internet-access
+#
+# For each permission it is important to also specify the reason why it is required.
+# Keep this a single short sentence without a period (.) at the end.
+# For longer explanations use the documentation or detail page.
+#
+# [permissions]
+# network = "Need to sync motion-capture data to server"
+# files = "Import/export FBX from/to disk"
+# clipboard = "Copy and paste bone transforms"
+
+# Optional: build settings.
+# https://docs.blender.org/manual/en/dev/advanced/extensions/command_line_arguments.html#command-line-args-extension-build
+# [build]
+# paths_exclude_pattern = [
+#   "__pycache__/",
+#   "/.git/",
+#   "/*.zip",
+# ]

bpy_speckle/callbacks/__init__.py

@@ -1,2 +0,0 @@
-from .on_mesh_edit import scb_on_mesh_edit
-from .draw_speckle_info import draw_speckle_info

bpy_speckle/callbacks/draw_speckle_info.py

@@ -1,23 +0,0 @@
-"""
-Drawing callback to display active Speckle user
-"""
-
-import blf
-import bpy
-
-
-def draw_speckle_info(self, context):
-    """
-    Draw active user info on the 3d viewport
-    """
-    scn = bpy.context.scene
-    if len(scn.speckle.users) > 0:
-        user = scn.speckle.users[int(scn.speckle.active_user)]
-        dpi = bpy.context.preferences.system.dpi
-
-        blf.position(0, 100, 50, 0)
-        blf.size(0, 20, dpi)
-        blf.draw(0, "Active Speckle user: {} ({})".format(user.name, user.email))
-        blf.position(0, 100, 20, 0)
-        blf.size(0, 16, dpi)
-        blf.draw(0, "Server: {}".format(user.server))

bpy_speckle/callbacks/on_mesh_edit.py

@@ -1,13 +0,0 @@
-import bpy
-from bpy.app.handlers import persistent
-
-
-@persistent
-def scb_on_mesh_edit(context):
-    """
-    DEPRECATED
-    Do something whenever a mesh is updated
-    """
-    edit_obj = bpy.context.edit_object
-    if edit_obj is not None and edit_obj.is_updated_data is True:
-        print("Mesh edited: {}".format(edit_obj))

bpy_speckle/clients.py

@@ -1,7 +0,0 @@
-"""
-Permanent handle on all user clients
-"""
-from specklepy.core.api.client import SpeckleClient
-
-
-speckle_clients: list[SpeckleClient] = []

bpy_speckle/connector/blender_operators/__init__.py

@@ -0,0 +1,3 @@
+from ..blender_operators.load_button import SPECKLE_OT_load # noqa: F401
+from ..blender_operators.publish_button import SPECKLE_OT_publish # noqa: F401
+from ..blender_operators.model_card_settings import SPECKLE_OT_model_card_settings # noqa: F401

bpy_speckle/connector/blender_operators/load_button.py

@@ -0,0 +1,27 @@
+import bpy
+from typing import Set
+from bpy.types import Context
+
+
+class SPECKLE_OT_load(bpy.types.Operator):
+    bl_idname = "speckle.load"
+    bl_label = "Load from Speckle"
+    bl_description = "Load objects from Speckle"
+
+    def invoke(self, context: Context, event: bpy.types.Event) -> Set[str]:
+        # Captures cursor position for UI placement
+        context.scene.speckle_state.mouse_position = (event.mouse_x, event.mouse_y)
+        return self.execute(context)
+
+    def execute(self, context: Context) -> Set[str]:
+        # Sets the UI mode to LOAD
+        context.scene.speckle_state.ui_mode = "LOAD"
+        # Logs cursor position
+        self.report(
+            {"INFO"},
+            f"Load button clicked at {context.scene.speckle_state.mouse_position[0], context.scene.speckle_state.mouse_position[1]}",
+        )
+        # Opens project_selection_dialog
+        bpy.ops.speckle.project_selection_dialog("INVOKE_DEFAULT")
+
+        return {"FINISHED"}

bpy_speckle/connector/blender_operators/model_card_settings.py

@@ -0,0 +1,72 @@
+import bpy
+import webbrowser
+from typing import Set
+from bpy.types import Event, Context, UILayout
+
+class SPECKLE_OT_model_card_settings(bpy.types.Operator):
+    """Manages settings and actions for a Speckle model card.
+
+
+    Attributes:
+        model_name (StringProperty): Name of the model being configured.
+    """
+    bl_idname = "speckle.model_card_settings"
+    bl_label = "Model Card Settings"
+    bl_description = "Settings for the model card"
+    model_card_index: bpy.props.IntProperty(name="Model Card Index", default=0) # type: ignore
+
+    def execute(self, context: Context) -> Set[str]:
+        self.report({'INFO'}, f"Settings for {context.scene.speckle_state.model_cards[self.model_card_index]}")
+        return {'FINISHED'}
+    
+    def draw(self, context: Context) -> None:
+        layout: UILayout = self.layout
+        # Add a button for viewing 3d model in the browser
+        layout.operator("speckle.view_in_browser", text="View in Browser").model_card_index = self.model_card_index
+        # Add a button for viewing model versions in the browser
+        layout.operator("speckle.view_model_versions", text="View Model Versions").model_card_index = self.model_card_index
+
+    def invoke(self, context: Context, event: Event) -> Set[str]:
+        wm = context.window_manager
+        return wm.invoke_props_dialog(self)
+
+# Operator for viewing the model in the browser
+class SPECKLE_OT_view_in_browser(bpy.types.Operator):
+    """Opens the current model in the Speckle web viewer.
+
+    This operator opens the default web browser to display the current
+    model in the Speckle web app.
+    """
+    bl_idname = "speckle.view_in_browser"
+    bl_label = "View in Browser"
+    bl_description = "View the model in the browser"
+
+    model_card_index: bpy.props.IntProperty() #type: ignore
+
+    def execute(self, context: Context) -> Set[str]:
+        model_card = context.scene.speckle_state.model_cards[self.model_card_index]
+        url = f"{model_card.server_url}/projects/{model_card.project_id}/models/{model_card.model_id}"
+        webbrowser.open(url)
+        self.report({'INFO'}, f"Viewing in the browser: {url}")
+        return {'FINISHED'}
+
+# Operator for viewing the model versions in the browser
+class SPECKLE_OT_view_model_versions(bpy.types.Operator):
+    """Opens the model's version history in the Speckle web app.
+
+    This operator opens the default web browser to display the version
+    history of the current model in the Speckle web app.
+    """
+    bl_idname = "speckle.view_model_versions"
+    bl_label = "View Model Versions"
+    bl_description = "View the model versions in the browser"
+
+    model_card_index: bpy.props.IntProperty() #type: ignore
+
+    def execute(self, context: Context) -> Set[str]:
+        model_card = context.scene.speckle_state.model_cards[self.model_card_index]
+        url = f"{model_card.server_url}/projects/{model_card.project_id}/models/{model_card.model_id}/versions"
+        webbrowser.open(url)
+
+        self.report({'INFO'}, "Viewing model's versions in the browser")
+        return {'FINISHED'}

bpy_speckle/connector/blender_operators/publish_button.py

@@ -0,0 +1,25 @@
+import bpy
+from bpy.types import Context
+from bpy.types import Event
+from typing import Set
+
+# Publish Operator
+class SPECKLE_OT_publish(bpy.types.Operator):
+    bl_idname = "speckle.publish"
+
+    bl_label = "Publish to Speckle"
+    bl_description = "Publish selected objects to Speckle"
+
+    def invoke(self, context: Context, event: Event) -> Set[str]:
+        # Captures the mouse position for UI placement
+        context.scene.speckle_state.mouse_position = (event.mouse_x, event.mouse_y)
+        return self.execute(context)
+
+    def execute(self, context: Context) -> Set[str]:
+        # Sets UI mode to PUBLISH
+        context.scene.speckle_state.ui_mode = "PUBLISH"
+        # Logs click position
+        self.report({'INFO'}, f"Publish button clicked at {context.scene.speckle_state.mouse_position[0], context.scene.speckle_state.mouse_position[1]}")
+        # Opens project selection dialog
+        bpy.ops.speckle.project_selection_dialog("INVOKE_DEFAULT")
+        return {'FINISHED'}

bpy_speckle/connector/blender_operators/select_objects.py

@@ -0,0 +1,50 @@
+import bpy
+from bpy.types import Operator
+from bpy.props import IntProperty
+
+class SPECKLE_OT_select_objects(Operator):
+    """Select all objects imported from this Speckle model"""
+    bl_idname = "speckle.select_objects"
+    bl_label = "Select Objects"
+    bl_options = {'REGISTER', 'UNDO'}
+    
+    model_card_index: IntProperty(
+        name="Model Card Index",
+        description="Index of the model card",
+        default=0
+    )
+    
+    def execute(self, context):
+        # Get the model card
+        model_card = context.scene.speckle_state.model_cards[self.model_card_index]
+        
+        # Construct collection name
+        collection_name = f"{model_card.model_name} - {model_card.version_id[:8]}"
+        
+        # Find the collection
+        collection = bpy.data.collections.get(collection_name)
+        if not collection:
+            self.report({'ERROR'}, f"Collection {collection_name} not found")
+            return {'CANCELLED'}
+            
+        # Deselect all objects first
+        bpy.ops.object.select_all(action='DESELECT')
+        
+        # Select all objects in the collection and its child collections
+        def select_collection_objects(collection):
+            for obj in collection.objects:
+                obj.select_set(True)
+            for child in collection.children:
+                select_collection_objects(child)
+        
+        select_collection_objects(collection)
+        
+        # Set active object to first selected object if any objects were selected
+        selected = context.selected_objects
+        if selected:
+            context.view_layer.objects.active = selected[0]
+            # Frame selected objects in the viewport
+            bpy.ops.view3d.view_selected()
+            
+        self.report({'INFO'}, f"Selected {len(context.selected_objects)} objects")
+        return {'FINISHED'}

bpy_speckle/connector/operations/__init__.py

@@ -0,0 +1,2 @@
+from ..blender_operators.load_button import SPECKLE_OT_load  # noqa: F401
+from ..operations.load_operation import load_operation  # noqa: F401

bpy_speckle/connector/operations/load_operation.py

@@ -0,0 +1,263 @@
+import bpy
+from bpy.types import Context
+from specklepy.api.credentials import get_local_accounts
+from specklepy.transports.server import ServerTransport
+from specklepy.api import operations
+from specklepy.api.client import SpeckleClient
+from specklepy.objects.models.collections.collection import Collection as SCollection
+from specklepy.objects.graph_traversal.default_traversal import (
+    create_default_traversal_function,
+)
+
+from ..utils.get_ascendants import get_ascendants
+from ...converter.to_native import convert_to_native, render_material_proxy_to_native
+
+
+def load_operation(context: Context, model_card) -> None:
+    """
+    load objects from Speckle and maintain hierarchy.
+    """
+
+    # get account
+    # to discuss: this looks redundant, we need to cache it somehow
+    account = next(
+        (
+            acc
+            for acc in get_local_accounts()
+            if acc.id == context.window_manager.selected_account_id
+        ),
+        None,
+    )
+
+    if account is None:
+        print("No Speckle account found")
+        return
+
+    # initialize the Speckle client
+    client = SpeckleClient(host=account.serverInfo.url)
+    # authenticate with account
+    client.authenticate_with_account(account)
+
+    # create a transport
+    transport = ServerTransport(stream_id=model_card.project_id, client=client)
+
+    # get the version
+    version = client.version.get(model_card.version_id, model_card.project_id)
+    obj_id = version.referenced_object
+
+    # receive the data
+    version_data = operations.receive(obj_id, transport)
+
+    # process materials from the root object
+    material_mapping = render_material_proxy_to_native(version_data)
+    print(f"Created material mapping for {len(material_mapping)} objects")
+
+    # default traversal function
+    traversal_function = create_default_traversal_function()
+
+    # create a root collection in Blender to hold all imported objects
+    root_collection_name = f"{model_card.model_name} - {model_card.version_id[:8]}"
+    root_collection = bpy.data.collections.new(root_collection_name)
+    context.scene.collection.children.link(root_collection)
+
+    # start conversion process
+    context.window_manager.progress_begin(0, 100)
+
+    # dictionary to track converted objects by Speckle ID
+    converted_objects = {}
+    # dictionary to track created collections by name to avoid duplicates
+    created_collections = {}
+    created_collections[root_collection_name] = root_collection
+
+    print("Creating collection hierarchy...")
+
+    # first create a complete map of the Speckle hierarchy
+    collection_hierarchy = {}
+    all_objects = {}
+
+    # track the root collection ID from Speckle
+    speckle_root_id = None
+
+    for traversal_item in traversal_function.traverse(version_data):
+        speckle_obj = traversal_item.current
+
+        if not hasattr(speckle_obj, "id"):
+            continue
+
+        # store all objects for later reference
+        all_objects[speckle_obj.id] = speckle_obj
+
+        # get all ascendants in order (current to root)
+        ascendants = list(get_ascendants(traversal_item))
+        parent_ascendants = ascendants[1:] if len(ascendants) > 1 else []
+
+        if isinstance(speckle_obj, SCollection):
+            # track the top-level collection (the one with no parents)
+            if not parent_ascendants and speckle_root_id is None:
+                speckle_root_id = speckle_obj.id
+
+            # get collection name
+            collection_name = getattr(
+                speckle_obj, "name", f"Collection_{speckle_obj.id[:8]}"
+            )
+
+            # find immediate parent collection if any
+            parent_id = None
+            for parent in parent_ascendants:
+                if isinstance(parent, SCollection) and hasattr(parent, "id"):
+                    parent_id = parent.id
+                    break
+
+            # store collection info
+            collection_hierarchy[speckle_obj.id] = {
+                "id": speckle_obj.id,
+                "name": collection_name,
+                "parent_id": parent_id,
+                "blender_collection": None,
+                "full_path": [collection_name],  # start the path with this collection
+            }
+
+            # build full path hierarchy
+            if parent_id in collection_hierarchy:
+                collection_hierarchy[speckle_obj.id]["full_path"] = (
+                    collection_hierarchy[parent_id]["full_path"] + [collection_name]
+                )
+
+        else:
+            # for non-collection objects, just store their parent information
+            if hasattr(speckle_obj, "id"):
+                # find immediate parent collection
+                parent_id = None
+                for parent in parent_ascendants:
+                    if isinstance(parent, SCollection) and hasattr(parent, "id"):
+                        parent_id = parent.id
+                        break
+
+    # create all collections in the right order
+    def get_collection_depth(coll_id):
+        parent_id = collection_hierarchy[coll_id]["parent_id"]
+        if parent_id is None:
+            return 0
+        if parent_id not in collection_hierarchy:
+            return 0
+        return 1 + get_collection_depth(parent_id)
+
+    # sort collections by depth to ensure parents are created before children
+    sorted_collections = sorted(
+        collection_hierarchy.keys(),
+        key=lambda coll_id: (
+            get_collection_depth(coll_id),
+            collection_hierarchy[coll_id]["name"],
+        ),
+    )
+
+    # map the Speckle root collection to our Blender root collection
+    if speckle_root_id and speckle_root_id in collection_hierarchy:
+        collection_hierarchy[speckle_root_id]["blender_collection"] = root_collection
+        converted_objects[speckle_root_id] = root_collection
+
+    # create collections in depth order (skip the root that's already mapped)
+    for coll_id in sorted_collections:
+        # skip the root collection (already handled)
+        if coll_id == speckle_root_id:
+            continue
+
+        coll_info = collection_hierarchy[coll_id]
+        coll_name = coll_info["name"]
+        parent_id = coll_info["parent_id"]
+        full_path = coll_info["full_path"]
+
+        # key to use for checking if collection already exists
+        collection_key = tuple(full_path)
+
+        # determine parent collection
+        parent_collection = root_collection
+        if parent_id and parent_id in collection_hierarchy:
+            parent_info = collection_hierarchy[parent_id]
+            if parent_info["blender_collection"]:
+                parent_collection = parent_info["blender_collection"]
+
+        # create or find the collection
+        if collection_key in created_collections:
+            blender_collection = created_collections[collection_key]
+
+        else:
+            blender_collection = bpy.data.collections.new(coll_name)
+            parent_collection.children.link(blender_collection)
+            created_collections[collection_key] = blender_collection
+
+        # store the created collection
+        coll_info["blender_collection"] = blender_collection
+        converted_objects[coll_id] = blender_collection
+
+    conversion_count = 0
+    for traversal_item in traversal_function.traverse(version_data):
+        speckle_obj = traversal_item.current
+
+        # skip collections (already handled)
+        if isinstance(speckle_obj, SCollection):
+            continue
+
+        # skip if already processed
+        if hasattr(speckle_obj, "id") and speckle_obj.id in converted_objects:
+            continue
+
+        try:
+            # convert here, passing the material mapping
+            blender_obj = convert_to_native(speckle_obj, material_mapping)
+            if blender_obj is None:
+                print(f"No converter found for: {speckle_obj.speckle_type}")
+                continue
+
+            # store the converted object
+            if hasattr(speckle_obj, "id"):
+                converted_objects[speckle_obj.id] = blender_obj
+
+            # determine which collection this object should be placed in
+            target_collection = root_collection
+            ascendants = list(get_ascendants(traversal_item))
+
+            # find immediate parent collection by walking up the hierarchy
+            for parent in ascendants[1:] if len(ascendants) > 1 else []:
+                if isinstance(parent, SCollection) and hasattr(parent, "id"):
+                    parent_id = parent.id
+                    if parent_id in collection_hierarchy:
+                        coll_info = collection_hierarchy[parent_id]
+                        if coll_info["blender_collection"]:
+                            target_collection = coll_info["blender_collection"]
+                            break
+
+            # link object to the target collection
+            try:
+                # check if already linked
+                already_linked = False
+                for coll in bpy.data.collections:
+                    if blender_obj.name in coll.objects:
+                        already_linked = True
+
+                if not already_linked:
+                    target_collection.objects.link(blender_obj)
+
+            except RuntimeError as e:
+                print(f"Error linking object to collection: {e}")
+
+        except Exception as e:
+            print(f"Error converting {speckle_obj.speckle_type}: {str(e)}")
+            import traceback
+
+            traceback.print_exc()
+
+        # update progress
+        conversion_count += 1
+        if conversion_count % 10 == 0:
+            context.window_manager.progress_update(min(conversion_count, 100))
+
+    # end progress bar
+    context.window_manager.progress_end()
+
+    # select the new collection in the outliner
+    for area in context.screen.areas:
+        if area.type == "OUTLINER":
+            area.tag_redraw()
+
+    print(f"Load process completed. Imported {len(converted_objects)} objects.")

bpy_speckle/connector/states/speckle_state.py

@@ -0,0 +1,30 @@
+import bpy
+from bpy.props import CollectionProperty, StringProperty, IntProperty, IntVectorProperty
+from bpy.types import PropertyGroup
+
+from ..ui.model_card import speckle_model_card
+
+class SpeckleState(PropertyGroup):
+    """Manages the state of the Speckle addon in Blender.
+
+    This class stores UI-related state information for the Speckle addon, including
+    the current UI mode, model cards collection, and UI interaction states.
+
+    Attributes:
+        ui_mode (StringProperty): Current UI mode of the addon. Defaults to "NONE".
+        model_cards (CollectionProperty): Collection of Speckle model cards.
+        model_card_index (IntProperty): Index of the currently selected model card.
+        mouse_position (IntVectorProperty): 2D vector storing current mouse position.
+    """
+    ui_mode: StringProperty(name="UI Mode", default="NONE")  # type: ignore
+    model_cards: CollectionProperty(type=speckle_model_card)  # type: ignore
+    model_card_index: IntProperty(name="Model Card Index", default=0)  # type: ignore
+    mouse_position: IntVectorProperty(size=2)  # type: ignore
+
+def register() -> None:
+    bpy.utils.register_class(SpeckleState)
+    bpy.types.Scene.speckle_state = bpy.props.PointerProperty(type=SpeckleState)  # type: ignore
+
+def unregister() -> None:
+    del bpy.types.Scene.speckle_state
+    bpy.utils.unregister_class(SpeckleState)

bpy_speckle/connector/ui/__init__.py

@@ -0,0 +1 @@
+from .main_panel import SPECKLE_PT_main_panel # noqa: F401

bpy_speckle/connector/ui/icons.py

@@ -0,0 +1,22 @@
+from typing import Optional, Dict
+import os
+import bpy.utils.previews
+
+speckle_icons: Optional[Dict[str, bpy.types.ImagePreview]] = None
+
+def load_icons() -> None:
+    global speckle_icons
+    speckle_icons = bpy.utils.previews.new()
+    icons_dir = os.path.dirname(__file__)
+    speckle_icons.load("speckle_logo", os.path.join(icons_dir, "speckle-logo.png"), 'IMAGE')
+
+def unload_icons() -> None:
+    global speckle_icons
+    if speckle_icons is not None:
+        bpy.utils.previews.remove(speckle_icons)
+
+def get_icon(icon_name: str) -> int:
+    global speckle_icons
+    if speckle_icons is None:
+        raise ValueError("Icons not loaded")
+    return speckle_icons[icon_name].icon_id

bpy_speckle/connector/ui/main_panel.py

@@ -0,0 +1,72 @@
+"""Module for handling the main Speckle panel.
+"""
+
+import bpy
+from bpy.types import UILayout, Context
+from .icons import get_icon
+
+# Main Panel
+class SPECKLE_PT_main_panel(bpy.types.Panel):
+    """Main panel for the Speckle addon.
+
+    This panel serves as the primary interface for the Speckle addon:
+    - Buttons for publishing and loading models
+    - Model cards showing the status of each Speckle model in the file
+    - Quick access to model settings and operations
+
+    The panel is displayed in the 3D View's sidebar under the 'Speckle' category.
+    """
+    bl_label = "Speckle"
+
+    bl_idname = "SPECKLE_PT_main_panel"
+    bl_space_type = 'VIEW_3D'
+    bl_region_type = 'UI'
+    bl_category = 'Speckle'
+
+    def draw(self, context: Context) -> None:
+        layout: UILayout = self.layout
+        layout.label(text="Speckle Connector BETA", icon_value=get_icon("speckle_logo"))
+
+        # Check to see if there are any speckle models in the file
+        if not context.scene.speckle_state.model_cards:
+            layout.label(text="Hello!")
+            layout.label(text="There are no Speckle models in this file yet.")
+
+        # Add some space
+        layout.separator()
+
+        # Publish and Load buttons
+        row: UILayout = layout.row()
+        # row.operator("speckle.publish", text="Publish", icon='EXPORT')
+        row.operator("speckle.load", text="Load", icon='IMPORT')
+
+        layout.separator()
+
+        for model_card_index, model_card in enumerate(context.scene.speckle_state.model_cards):
+            box: UILayout = layout.box()
+            row: UILayout = box.row()
+            icon: str = 'EXPORT' if model_card.is_publish else 'IMPORT'
+            row.operator("speckle.publish", text="", icon=icon)
+            row.label(text=f"{model_card.model_name} - {model_card.project_name}")
+            # Add selection button
+            select_op = row.operator("speckle.select_objects", text="", icon='RESTRICT_SELECT_OFF')
+            select_op.model_card_index = model_card_index
+            row.operator("speckle.model_card_settings", text="", icon='PREFERENCES').model_card_index = model_card_index
+            row: UILayout = box.row()
+            # Display selection summary or version ID
+            if model_card.is_publish:
+                # This adjusts the layout of the row (button 1/3, label 2/3 )
+                split: UILayout = row.split(factor=0.33)
+                # TODO: Connect to selection operator
+                split.operator("speckle.publish", text="Selection")
+                split.label(text=f"{model_card.selection_summary}")
+            else:
+                # This adjusts the layout of the row (button 1/3, label 2/3 )
+                split: UILayout = row.split(factor=0.33)
+                # TODO: Connect to version operator
+                if model_card.load_option == "LATEST":
+                    split.operator("speckle.load", text="Latest")
+                if model_card.load_option == "SPECIFIC":
+                    split.operator("speckle.load", text=f"{model_card.version_id}")
+                # TODO: Get last updated time
+                split.label(text="Last updated: 2 days ago")

bpy_speckle/connector/ui/model_card.py

@@ -0,0 +1,63 @@
+import bpy
+from typing import Dict, Any
+class speckle_model_card(bpy.types.PropertyGroup):
+    """Represents a Speckle model card in the Blender UI.
+
+    This class stores information about a Speckle model, including its project name,
+    whether if its publish or load, and version information. It is used to display and manage model
+    cards in the Blender interface.
+
+    Attributes:
+        project_name (StringProperty): Name of the project containing the model.
+        model_name (StringProperty): Name of the Speckle model.
+        is_publish (BoolProperty): Flag indicating if the model is being published (True) or loaded (False).
+        selection_summary (StringProperty): Summary text of the current object selection.
+        version_id (StringProperty): Unique identifier of the selected version.
+    """
+    server_url: bpy.props.StringProperty(name="Server URL", description="URL of the Server", default="app.speckle.systems")  # type: ignore
+    project_name: bpy.props.StringProperty(name="Project Name", description="Name of the project", default="")  # type: ignore
+    project_id: bpy.props.StringProperty(name="Project ID", description="ID of the selected project", default="") # type: ignore
+    model_id: bpy.props.StringProperty(name="Model ID", description="ID of the model", default="") # type: ignore
+    model_name: bpy.props.StringProperty(name="Model Name", description="Name of the model", default="")  # type: ignore
+    is_publish: bpy.props.BoolProperty(name="Publish/Load", description="If the model is published or loaded", default=False)  # type: ignore
+    selection_summary: bpy.props.StringProperty(name="Selection Summary", description="Summary of the selection", default="")  # type: ignore
+    version_id: bpy.props.StringProperty(name="Version ID", description="ID of the selected version", default="")  # type: ignore
+    load_option: bpy.props.StringProperty(name="Version ID", description="ID of the selected version", default="")  # type: ignore
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Converts the model card to a dictionary representation.
+
+        Returns:
+            dict: A dictionary containing all model card properties with their current values.
+        """
+        return {
+            "server_url": self.server_url,
+            "project_name": self.project_name,
+            "project_id": self.project_id,
+            "model_id": self.model_id,
+            "model_name": self.model_name,
+            "is_publish": self.is_publish,
+            "selection_summary": self.selection_summary,
+            "version_id": self.version_id,
+        }
+    
+    @classmethod
+    def from_dict(cls, data):
+        """Creates a new model card instance from a dictionary.
+
+        Args:
+            data (dict): Dictionary containing model card properties and their values.
+
+        Returns:
+            speckle_model_card: A new instance of the model card with properties set from the dictionary.
+        """
+        item = cls()
+        item.server_url = data["server_url"]
+        item.project_name = data["project_name"]
+        item.project_id = data["project_id"]
+        item.model_id = data["model_id"]
+        item.model_name = data["model_name"]
+        item.is_publish = data["is_publish"]
+        item.selection_summary = data["selection_summary"]
+        item.version_id = data["version_id"]
+        

bpy_speckle/connector/ui/model_selection_dialog.py

@@ -0,0 +1,179 @@
+"""Module for handling model selection dialog in the Speckle Blender addon.
+
+This module provides the UI components and functionality for selecting models
+from Speckle projects within Blender.
+"""
+
+import bpy
+from bpy.types import UILayout, Context, PropertyGroup, Event, WindowManager
+from .mouse_position_mixin import MousePositionMixin
+from ..utils.model_manager import get_models_for_project
+
+class speckle_model(bpy.types.PropertyGroup):
+    """PropertyGroup for storing model information.
+
+    This class stores information about a Speckle model including its name,
+    ID, and last update time for display in the model selection dialog.
+
+    Attributes:
+        name: The display name of the model.
+        id: The unique identifier of the model.
+        updated: The last update timestamp of the model.
+    """
+    # Blender properties use dynamic typing, so we need to ignore type checking
+    name: bpy.props.StringProperty()  # type: ignore
+    id: bpy.props.StringProperty(name="ID")  # type: ignore
+    updated: bpy.props.StringProperty(name="Updated")  # type: ignore
+
+class SPECKLE_UL_models_list(bpy.types.UIList):
+    """UIList for displaying a list of Speckle models.
+
+    This class handles the visual representation of models in the model selection dialog.
+    It displays model information in both default/compact and grid layouts.
+    """
+
+    def draw_item(self, context: Context, layout: UILayout, data: PropertyGroup, item: PropertyGroup, 
+                 icon: str, active_data: PropertyGroup, active_propname: str) -> None:
+        """Draws a single item in the model list.
+
+        Args:
+            context: The current Blender context.
+            layout: The layout to draw the item in.
+            data: The data containing the item.
+            item: The item to draw.
+            icon: The icon to use for the item.
+            active_data: The data containing the active item.
+            active_propname: The name of the active property.
+        """
+        if self.layout_type in {'DEFAULT', 'COMPACT'}:
+            row = layout.row(align=True)
+            split = row.split(factor=0.5)
+            split.label(text=item.name)
+
+            right_split = split.split(factor=0.25)
+            right_split.label(text=item.id)
+            right_split.label(text=item.updated)
+        # This handles when the list is in a grid layout
+        elif self.layout_type == 'GRID':
+            layout.alignment = 'CENTER'
+            layout.label(text=item.name)
+
+class SPECKLE_OT_model_selection_dialog(MousePositionMixin, bpy.types.Operator):
+    """Operator for displaying and handling the model selection dialog.
+
+    This operator manages the UI and functionality for selecting Speckle models,
+    including search capabilities and model list display.
+
+    Attributes:
+        search_query: The current search string for filtering models.
+        project_name: The name of the currently selected project.
+        project_id: The ID of the currently selected project.
+        model_index: The index of the currently selected model.
+    """
+    bl_idname = "speckle.model_selection_dialog"
+    bl_label = "Select Model"
+
+    def update_models_list(self, context: Context) -> None:
+        """Updates the list of models based on the current project and search query.
+
+        Args:
+            context: The current Blender context.
+        """
+        wm = context.window_manager
+        # Clear existing models
+        wm.speckle_models.clear()
+        
+        # Get models for the selected project, using search if provided
+        search = self.search_query if self.search_query.strip() else None
+        models = get_models_for_project(wm.selected_account_id, self.project_id, search=search)
+        
+        # Populate models list
+        for name, id, updated in models:
+            model = wm.speckle_models.add()
+            model.name = name
+            model.updated = updated
+            model.id = id
+            
+        return None
+
+    search_query: bpy.props.StringProperty(  # type: ignore
+        name="Search",
+        description="Search a model",
+        default="",
+        update=update_models_list
+    )
+
+    project_name: bpy.props.StringProperty(  # type: ignore
+        name="Project Name",
+        description="The name of the project to select",
+        default=""
+    )
+
+    project_id: bpy.props.StringProperty(  # type: ignore
+        name="Project ID",
+        description="The ID of the project to select",
+        default=""
+    )
+
+    model_index: bpy.props.IntProperty(name="Model Index", default=0)  # type: ignore
+
+    def execute(self, context: Context) -> set[str]:
+        selected_model = context.window_manager.speckle_models[self.model_index]
+        if context.scene.speckle_state.ui_mode == "PUBLISH":
+            bpy.ops.speckle.selection_filter_dialog("INVOKE_DEFAULT", 
+                project_name=self.project_name, 
+                project_id=self.project_id,
+                model_name=selected_model.name,
+                model_id=selected_model.id)
+        elif context.scene.speckle_state.ui_mode == "LOAD":
+            bpy.ops.speckle.version_selection_dialog("INVOKE_DEFAULT", 
+                project_name=self.project_name,
+                project_id=self.project_id,
+                model_name=selected_model.name,
+                model_id=selected_model.id)
+        return {'FINISHED'}
+
+    def invoke(self, context: Context, event: Event) -> set[str]:
+        
+        # Ensure WindowManager has the projects collection
+        if not hasattr(WindowManager, "speckle_models"):
+            # Register the collection property
+            WindowManager.speckle_models = bpy.props.CollectionProperty(type=speckle_model)
+
+        # Update models list
+        self.update_models_list(context)
+
+        # Store the original mouse position
+        self.init_mouse_position(context, event)
+
+        return context.window_manager.invoke_props_dialog(self)
+    
+    def draw(self, context: Context) -> None:
+        layout : UILayout = self.layout
+        layout.label(text=f"Project: {self.project_name}")
+        
+        # Search field
+        row = layout.row(align=True)
+        row.prop(self, "search_query", icon='VIEWZOOM', text="")
+        
+        # Models UIList
+        layout.template_list("SPECKLE_UL_models_list", "", context.window_manager, "speckle_models", self, "model_index")
+
+        layout.separator()
+
+        # Move cursor to original position
+        self.restore_mouse_position(context)
+
+def register() -> None:
+    bpy.utils.register_class(speckle_model)
+    bpy.utils.register_class(SPECKLE_UL_models_list)
+    bpy.utils.register_class(SPECKLE_OT_model_selection_dialog)
+
+def unregister() -> None:
+    # Clean up WindowManager properties
+    if hasattr(WindowManager, "speckle_models"):
+        del WindowManager.speckle_models
+    
+    bpy.utils.unregister_class(SPECKLE_OT_model_selection_dialog)
+    bpy.utils.unregister_class(SPECKLE_UL_models_list)
+    bpy.utils.unregister_class(speckle_model)

bpy_speckle/connector/ui/mouse_position_mixin.py

@@ -0,0 +1,16 @@
+import bpy
+from bpy.types import Context, Event
+
+class MousePositionMixin:
+    original_mouse_position: bpy.props.IntVectorProperty(size=2) # type: ignore
+    mouse_snap: bpy.props.BoolProperty(name="Mouse Snap", default=False) # type: ignore
+
+    def init_mouse_position(self, context: Context, event: Event) -> None:
+        self.original_mouse_position = (event.mouse_x, event.mouse_y)
+        self.mouse_snap = False
+        context.window.cursor_warp(context.scene.speckle_state.mouse_position[0], context.scene.speckle_state.mouse_position[1])
+
+    def restore_mouse_position(self, context: Context) -> None:
+        if not self.mouse_snap:
+            self.mouse_snap = True
+            context.window.cursor_warp(self.original_mouse_position[0], self.original_mouse_position[1])

bpy_speckle/connector/ui/project_selection_dialog.py

@@ -0,0 +1,225 @@
+"""Module for handling project selection dialog in the Speckle Blender addon.
+
+This module provides the UI components and functionality for selecting projects
+from Speckle accounts within Blender.
+"""
+
+import bpy
+from bpy.types import UILayout, Context, PropertyGroup, Event, WindowManager
+from typing import List, Tuple
+from ..utils.account_manager import get_account_enum_items, get_default_account_id
+from ..utils.project_manager import get_projects_for_account
+
+class speckle_project(bpy.types.PropertyGroup):
+    """PropertyGroup for storing project information.
+
+    This class stores information about a Speckle project including its name,
+    role, update time, and ID for display in the project selection dialog.
+
+    Attributes:
+        name: The display name of the project.
+        role: User's role in the project.
+        updated: The last update timestamp of the project.
+        id: The unique identifier of the project.
+    """
+    # Blender properties use dynamic typing, so we need to ignore type checking
+    name: bpy.props.StringProperty()  # type: ignore
+    role: bpy.props.StringProperty(name="Role")  # type: ignore
+    updated: bpy.props.StringProperty(name="Updated")  # type: ignore
+    id: bpy.props.StringProperty(name="ID")  # type: ignore
+
+class SPECKLE_UL_projects_list(bpy.types.UIList):
+    """UIList for displaying a list of Speckle projects.
+
+    This class handles the visual representation of projects in the project selection dialog.
+    It displays project information in both default/compact and grid layouts.
+    """
+
+    def draw_item(self, context: Context, layout: UILayout, data: PropertyGroup, item: PropertyGroup, icon: str, active_data: PropertyGroup, active_propname: str) -> None:
+        """Draws a single item in the project list.
+
+        Args:
+            context: The current Blender context.
+            layout: The layout to draw the item in.
+            data: The data containing the item.
+            item: The item to draw.
+            icon: The icon to use for the item.
+            active_data: The data containing the active item.
+            active_propname: The name of the active property.
+        """
+        if self.layout_type in {'DEFAULT', 'COMPACT'}:
+            row = layout.row(align=True)
+            split = row.split(factor=0.5) # This gives project name 1/2
+            split.label(text=item.name)
+            
+            right_split = split.split(factor=0.5) # This gives project role and updated the other 1/2 of the row
+            right_split.label(text=item.role)
+            right_split.label(text=item.updated)
+        # This handles when the list is in a grid layout
+        elif self.layout_type == 'GRID':
+            layout.alignment = 'CENTER'
+            layout.label(text=item.name)
+
+class SPECKLE_OT_project_selection_dialog(bpy.types.Operator):
+    """Operator for displaying and handling the project selection dialog.
+
+    This operator manages the UI and functionality for selecting Speckle projects,
+    including account selection and project list display.
+
+    Attributes:
+        search_query: The current search string for filtering projects.
+        accounts: Available Speckle accounts for selection.
+        project_index: The index of the currently selected project.
+    """
+    bl_idname = "speckle.project_selection_dialog"
+    bl_label = "Select Project"
+
+    def update_projects_list(self, context: Context) -> None:
+        """Updates the list of projects based on the selected account and search query.
+
+        Args:
+            context: The current Blender context.
+        """
+        wm = context.window_manager
+        
+        # Update the selected account ID in the window manager
+        wm.selected_account_id = self.accounts
+        
+        # Clear existing projects
+        wm.speckle_projects.clear()
+        
+        # Get projects for the selected account, using search if provided
+        search = self.search_query if self.search_query.strip() else None
+        projects: List[Tuple[str, str, str, str]] = get_projects_for_account(self.accounts, search=search)
+        
+        # Populate projects list in WindowManager
+        for name, role, updated, id in projects:
+            project: speckle_project = wm.speckle_projects.add()
+            project.name = name
+            project.role = role
+            project.updated = updated
+            project.id = id
+            
+        return None
+
+    search_query: bpy.props.StringProperty(  # type: ignore
+        name="Search or Paste a URL",
+        description="Search a project or paste a URL to add a project",
+        default="",
+        update=update_projects_list
+    )
+
+    accounts: bpy.props.EnumProperty(  # type: ignore
+        name="Account",
+        description="Selected account to filter projects by",
+        items=get_account_enum_items(),
+        default=get_default_account_id(),
+        update=update_projects_list
+    )
+
+    project_index: bpy.props.IntProperty(name="Project Index", default=0)  # type: ignore
+    
+    def execute(self, context: Context) -> set[str]:
+        wm = context.window_manager
+        if 0 <= self.project_index < len(wm.speckle_projects):
+            selected_project = wm.speckle_projects[self.project_index]
+            bpy.ops.speckle.model_selection_dialog("INVOKE_DEFAULT", project_name=selected_project.name, project_id=selected_project.id)
+        return {'FINISHED'}
+    
+    def invoke(self, context: Context, event: Event) -> set[str]:
+        wm = context.window_manager
+        
+        # Ensure WindowManager has the projects collection
+        if not hasattr(WindowManager, "speckle_projects"):
+            # Register the collection property
+            WindowManager.speckle_projects = bpy.props.CollectionProperty(type=speckle_project)
+        
+        # Clear existing projects
+        wm.speckle_projects.clear()
+        
+        # Get the selected account
+        selected_account_id = self.accounts
+
+        if not hasattr(WindowManager, "selected_account_id"):
+            # Register the collection property
+            WindowManager.selected_account_id = bpy.props.StringProperty()
+        wm.selected_account_id = selected_account_id
+        
+        # Fetch projects from server
+        projects: List[Tuple[str, str, str, str]] = get_projects_for_account(selected_account_id)
+        
+        # Populate projects list in WindowManager
+        for name, role, updated, id in projects:
+            project: speckle_project = wm.speckle_projects.add()
+            project.name = name
+            project.role = role
+            project.updated = updated
+            project.id = id
+            
+        return context.window_manager.invoke_props_dialog(self)
+
+    def draw(self, context: Context) -> None:
+        layout: UILayout = self.layout
+        
+        # Account selection
+        layout.prop(self, "accounts", text="")
+        
+        # Search field
+        row = layout.row(align=True)
+        row.prop(self, "search_query", icon='VIEWZOOM', text="")
+        # TODO: Add a button for adding a project by URL
+        #row.operator("speckle.add_project_by_url", icon='URL', text="")
+        
+        # Projects UIList - now using WindowManager collection
+        layout.template_list(
+            "SPECKLE_UL_projects_list", "",
+            context.window_manager, "speckle_projects",
+            self, "project_index"
+        )
+        layout.separator()
+
+class SPECKLE_OT_add_project_by_url(bpy.types.Operator):
+    """Operator for adding a Speckle project by URL.
+
+    This operator allows users to add a Speckle project by providing its URL.
+
+    Attributes:
+        url: The URL of the Speckle project to add.
+    """
+    bl_idname = "speckle.add_project_by_url"
+    bl_label = "Add Project by URL"
+    bl_description = "Add a project from a URL"
+    
+    url: bpy.props.StringProperty(  # type: ignore
+        name="Project URL",
+        description="Enter the Speckle project URL",
+        default=""
+    )
+
+    def execute(self, context: Context) -> set[str]:
+        # TODO: Implement logic to add project using the URL
+        self.report({'INFO'}, f"Adding project from URL: {self.url}")
+        return {'FINISHED'}
+
+    def invoke(self, context: Context, event: Event) -> set[str]:
+        return context.window_manager.invoke_props_dialog(self)
+
+    def draw(self, context: Context) -> None:
+        layout: UILayout = self.layout
+        layout.prop(self, "url")
+
+def register() -> None:
+    bpy.utils.register_class(speckle_project)
+    bpy.utils.register_class(SPECKLE_UL_projects_list)
+    bpy.utils.register_class(SPECKLE_OT_project_selection_dialog)
+    bpy.utils.register_class(SPECKLE_OT_add_project_by_url)
+
+def unregister() -> None:
+    # Clean up WindowManager properties
+    if hasattr(WindowManager, "speckle_projects"):
+        del WindowManager.speckle_projects
+    
+    bpy.utils.unregister_class(SPECKLE_OT_add_project_by_url)
+    bpy.utils.unregister_class(SPECKLE_OT_project_selection_dialog)
+    bpy.utils.unregister_class(SPECKLE_UL_projects_list)
+    bpy.utils.unregister_class(speckle_project)

bpy_speckle/connector/ui/selection_filter_dialog.py

@@ -0,0 +1,149 @@
+"""Module for handling object selection filtering.
+
+This module provides the UI components and functionality for filtering and selecting
+Blender objects for publishing to Speckle.
+"""
+
+import bpy
+from typing import List
+from .mouse_position_mixin import MousePositionMixin
+from bpy.types import Operator, Context, Object
+from bpy.props import EnumProperty, StringProperty
+
+class SPECKLE_OT_selection_filter_dialog(MousePositionMixin, Operator):
+    """Operator for handling object selection and filtering.
+
+    This operator manages the UI and functionality for selecting and filtering
+    Blender objects before publishing to Speckle, including selection type options
+    and selection summary display.
+
+    Attributes:
+        selection_type: The type of selection method to use.
+        project_name: The name of the selected project.
+        project_id: The ID of the selected project.
+        model_name: The name of the selected model.
+        model_id: The ID of the selected model.
+    """
+    bl_idname = "speckle.selection_filter_dialog"
+    bl_label = "Select Objects"
+
+    selection_type: EnumProperty(
+        name="Selection",
+        items=[
+            ("SELECTION", "Selection", "Select objects manually"),
+        ],
+        default="SELECTION"
+    ) # type: ignore
+
+    project_name: StringProperty(
+        name="Project Name",
+        description="Name of the selected project",
+        default=""
+    ) # type: ignore
+
+    project_id: StringProperty(
+        name="Project ID",
+        description="ID of the selected project",
+        default=""
+    ) # type: ignore
+
+    model_name: StringProperty(
+        name="Model Name",
+        description="Name of the selected model",
+        default=""
+    ) # type: ignore
+
+    model_id: StringProperty(
+        name="Model ID",
+        description="ID of the selected model",
+        default=""
+    ) # type: ignore
+
+    def execute(self, context: Context) -> set:
+        model_card = context.scene.speckle_state.model_cards.add()
+        model_card.project_name = self.project_name
+        model_card.model_name = self.model_name
+        model_card.model_id = self.model_id
+        model_card.project_id = self.project_id
+        model_card.is_publish = True
+
+        # Create the selection summary
+        selected_objects: list[Object] = context.selected_objects
+        total_selected: int = len(selected_objects)
+        object_types: dict[str, int] = {}
+        for obj in selected_objects:
+            if obj.type not in object_types:
+                object_types[obj.type] = 1
+            else:
+                object_types[obj.type] += 1
+
+        summary: str = f"{total_selected} objects - "
+        for obj_type, count in object_types.items():
+            summary += f"{obj_type}: {count}, "
+
+        model_card.selection_summary = summary.strip()
+        return {'FINISHED'}
+
+    def invoke(self, context: Context, event: bpy.types.Event) -> set:
+        # Initialize mouse position
+        self.init_mouse_position(context, event)
+        return context.window_manager.invoke_props_dialog(self)
+
+    def draw(self, context: Context):
+        layout = self.layout
+
+        layout.label(text=f"Project: {self.project_name}")
+        layout.label(text=f"Model: {self.model_name}")
+
+        # Selection dropdown
+        layout.prop(self, "selection_type")
+        layout.separator()
+
+        # Get selected objects
+        selected_objects: List[Object] = context.selected_objects
+        total_selected: int = len(selected_objects)
+
+        # Create a box for the selection summary
+        box = layout.box()
+        row = box.row()
+        row.label(text="Selection Summary", icon='OUTLINER_OB_GROUP_INSTANCE')
+        row.label(text=f"Total: {total_selected}", icon='OBJECT_DATA')
+
+        # Display object types and counts
+        object_types: dict[str, int] = {}
+        for obj in selected_objects:
+            if obj.type not in object_types:
+                object_types[obj.type] = 1
+            else:
+                object_types[obj.type] += 1
+
+        col = box.column(align=True)
+        for obj_type, count in object_types.items():
+            row = col.row()
+            row.label(text=f"{obj_type}:", icon=self.get_icon_for_type(obj_type))
+            row.label(text=str(count))
+
+        layout.separator()
+
+        # Restore mouse position
+        self.restore_mouse_position(context)
+    def get_icon_for_type(self, obj_type: str) -> str:
+        icon_map: dict[str, str] = {
+            'MESH': 'OUTLINER_OB_MESH',
+            'CURVE': 'OUTLINER_OB_CURVE',
+            'SURFACE': 'OUTLINER_OB_SURFACE',
+            'META': 'OUTLINER_OB_META',
+            'FONT': 'OUTLINER_OB_FONT',
+            'ARMATURE': 'OUTLINER_OB_ARMATURE',
+            'LATTICE': 'OUTLINER_OB_LATTICE',
+            'EMPTY': 'OUTLINER_OB_EMPTY',
+            'GPENCIL': 'OUTLINER_OB_GREASEPENCIL',
+            'CAMERA': 'OUTLINER_OB_CAMERA',
+            'LIGHT': 'OUTLINER_OB_LIGHT',
+            'SPEAKER': 'OUTLINER_OB_SPEAKER',
+            'LIGHT_PROBE': 'OUTLINER_OB_LIGHTPROBE',
+        }
+        return icon_map.get(obj_type, 'OBJECT_DATA')
+
+    def check(self, context: Context) -> bool:
+        return True  # This forces the dialog to redraw

bpy_speckle/connector/ui/version_selection_dialog.py

@@ -0,0 +1,227 @@
+"""Module for handling version selection dialog in the Speckle Blender addon.
+
+Provides the UI components and functionality for selecting versions.
+"""
+
+import bpy
+from bpy.types import WindowManager, UILayout, Context, PropertyGroup, Event
+from .mouse_position_mixin import MousePositionMixin
+from ..utils.version_manager import get_versions_for_model, get_latest_version
+from ..utils.account_manager import get_server_url_by_account_id
+from ..operations.load_operation import load_operation
+
+
+class speckle_version(bpy.types.PropertyGroup):
+    """PropertyGroup for storing version information.
+
+    This class stores information about a Speckle version including its ID,
+    version message, update time, and source application for display in the
+    version selection dialog.
+
+    Attributes:
+        id: The unique identifier of the version.
+        message: The version message associated with the version.
+        updated: The last update timestamp of the version.
+        source_app: The application that created this version.
+    """
+
+    # Blender properties use dynamic typing, so we need to ignore type checking
+    id: bpy.props.StringProperty(name="ID")  # type: ignore
+    message: bpy.props.StringProperty(name="Message")  # type: ignore
+    updated: bpy.props.StringProperty(name="Updated")  # type: ignore
+    source_app: bpy.props.StringProperty(name="Source")  # type: ignore
+
+
+class SPECKLE_UL_versions_list(bpy.types.UIList):
+    """UIList for displaying a list of Speckle versions.
+
+    It displays version information in both default/compact and grid layouts.
+    """
+
+    # TODO: Adjust column widths so message has the most space.
+    def draw_item(
+        self,
+        context: Context,
+        layout: UILayout,
+        data: PropertyGroup,
+        item: PropertyGroup,
+        icon: str,
+        active_data: PropertyGroup,
+        active_propname: str,
+    ) -> None:
+        """Draws a single item in the version list.
+
+        Args:
+            context: The current Blender context.
+            layout: The layout to draw the item in.
+            data: The data containing the item.
+            item: The item to draw.
+            icon: The icon to use for the item.
+
+            active_data: The data containing the active item.
+            active_propname: The name of the active property.
+        """
+        if self.layout_type in {"DEFAULT", "COMPACT"}:
+            row = layout.row(align=True)
+            split = row.split(factor=0.166)
+            split.label(text=item.id)
+            right_split = split.split(factor=0.7)
+            right_split.label(text=item.message)
+            right_split.label(text=item.updated)
+        # This handles when the list is in a grid layout
+        elif self.layout_type == "GRID":
+            layout.alignment = "CENTER"
+            layout.label(text=item.id)
+
+
+class SPECKLE_OT_version_selection_dialog(MousePositionMixin, bpy.types.Operator):
+    """Operator for displaying and handling the version selection dialog.
+
+    This operator manages the UI and functionality for selecting Speckle versions,
+    including version list display and search capabilities.
+
+    Attributes:
+        search_query: The current search string for filtering versions.
+        project_name: The name of the selected project.
+        model_name: The name of the selected model.
+        project_id: The ID of the selected project.
+        model_id: The ID of the selected model.
+        version_index: The index of the currently selected version.
+    """
+
+    bl_idname = "speckle.version_selection_dialog"
+    bl_label = "Select Version"
+
+    search_query: bpy.props.StringProperty(  # type: ignore
+        name="Search", description="Search a project", default=""
+    )
+
+    project_name: bpy.props.StringProperty(  # type: ignore
+        name="Project Name", description="Name of the selected project", default=""
+    )
+
+    model_name: bpy.props.StringProperty(  # type: ignore
+        name="Model Name", description="Name of the selected model", default=""
+    )
+
+    project_id: bpy.props.StringProperty(  # type: ignore
+        name="Project ID", description="ID of the selected project", default=""
+    )
+
+    model_id: bpy.props.StringProperty(  # type: ignore
+        name="Model ID", description="ID of the selected model", default=""
+    )
+
+    version_index: bpy.props.IntProperty(name="Model Index", default=0)  # type: ignore
+
+    load_option: bpy.props.EnumProperty(  # type: ignore
+        name="Load Option",
+        description="Choose how to load the version",
+        items=[
+            ("LATEST", "Load latest version", "Load the latest version available"),
+            (
+                "SPECIFIC",
+                "Load a specific version",
+                "Load a specific version from the list",
+            ),
+        ],
+        default="LATEST",
+    )
+
+    def update_versions_list(self, context: Context) -> None:
+        wm = context.window_manager
+        # Clear existing versions
+        wm.speckle_versions.clear()
+
+        # Get versions for the selected model
+        search = self.search_query if self.search_query.strip() else None
+        versions = get_versions_for_model(
+            account_id=wm.selected_account_id,
+            project_id=self.project_id,
+            model_id=self.model_id,
+            search=search,
+        )
+
+        # Populate versions list
+        for id, message, updated in versions:
+            version = wm.speckle_versions.add()
+            version.id = id
+            version.message = message
+            version.updated = updated
+
+        return None
+
+    def execute(self, context: Context) -> set[str]:
+        wm = context.window_manager
+        model_card = context.scene.speckle_state.model_cards.add()
+        model_card.server_url = get_server_url_by_account_id(
+            account_id=wm.selected_account_id
+        )
+        model_card.project_name = self.project_name
+        model_card.project_id = self.project_id
+        model_card.model_id = self.model_id
+        model_card.model_name = self.model_name
+        model_card.is_publish = False
+        model_card.load_option = self.load_option
+        # Store the selected version ID
+        if self.load_option == "LATEST":
+            version_id, _, _ = get_latest_version(
+                account_id=context.window_manager.selected_account_id,
+                project_id=self.project_id,
+                model_id=self.model_id,
+            )
+            model_card.version_id = version_id
+        else:  # SPECIFIC
+            selected_version = context.window_manager.speckle_versions[
+                self.version_index
+            ]
+            model_card.version_id = selected_version.id
+
+        # Call the load process class method
+        load_operation(context=context, model_card=model_card)
+
+        return {"FINISHED"}
+
+    def invoke(self, context: Context, event: Event) -> set[str]:
+        # Ensure WindowManager has the versions collection
+        if not hasattr(WindowManager, "speckle_versions"):
+            # Register the collection property
+            WindowManager.speckle_versions = bpy.props.CollectionProperty(
+                type=speckle_version
+            )
+
+        # Update versions list
+        self.update_versions_list(context)
+
+        # Initialize mouse position
+        self.init_mouse_position(context, event)
+
+        return context.window_manager.invoke_props_dialog(self)
+
+    def draw(self, context: Context) -> None:
+        layout: UILayout = self.layout
+        layout.label(text=f"Project: {self.project_name}")
+        layout.label(text=f"Model: {self.model_name}")
+
+        # Radio buttons for load options
+        layout.prop(self, "load_option", expand=True)
+
+        # Show search field and version list only if "Load a specific version" is selected
+        if self.load_option == "SPECIFIC":
+            # Search field
+            row = layout.row(align=True)
+            row.prop(self, "search_query", icon="VIEWZOOM", text="")
+            # Versions UIList
+            layout.template_list(
+                "SPECKLE_UL_versions_list",
+                "",
+                context.window_manager,
+                "speckle_versions",
+                self,
+                "version_index",
+            )
+
+        layout.separator()
+
+        # Restore mouse position
+        self.restore_mouse_position(context)

bpy_speckle/connector/utils/account_manager.py

@@ -0,0 +1,53 @@
+from specklepy.api.credentials import get_local_accounts
+from typing import List, Tuple, Optional
+from specklepy.core.api.credentials import Account
+
+
+def get_account_enum_items() -> List[Tuple[str, str, str]]:
+    """Retrieves a list of Speckle accounts formatted for Blender enum properties.
+
+    This function fetches all local Speckle accounts and formats them for use in Blender's
+    UI dropdown menus. If no accounts are found, it returns a single entry indicating that
+    no accounts are available.
+
+    Returns:
+        List[Tuple[str, str, str]]: A list of tuples where each tuple contains:
+            - identifier (str): The account ID or "NO_ACCOUNTS" if none found
+            - name (str): Display string with format "username - server - email" or error message
+            - description (str): Empty string, reserved for future use
+
+    Note:
+        If no accounts are found, returns a single tuple with instructions for adding an account.
+    """
+    accounts: List[Account] = get_local_accounts()
+    if not accounts:
+        return [("NO_ACCOUNTS", "No accounts found! Please add an account from Manager for Speckle.", "")]
+    return [(acc.id, f"{acc.userInfo.name} - {acc.serverInfo.url} - {acc.userInfo.email}", "") for acc in accounts]
+
+
+def get_default_account_id() -> Optional[str]:
+    """Retrieves the ID of the default Speckle account.
+
+    This function searches through all local Speckle accounts and returns the ID
+    of the account marked as default.
+
+    Returns:
+        Optional[str]: The ID of the default account if one exists, None otherwise.
+    """
+    return next((acc.id for acc in get_local_accounts() if acc.isDefault), None)
+
+
+def get_server_url_by_account_id(account_id: str) -> Optional[str]:
+    """Retrieves the server URL for a given account ID.
+
+    Args:
+        account_id (str): The ID of the account.
+
+    Returns:
+        Optional[str]: The server URL if the account is found, otherwise None.
+    """
+    accounts: List[Account] = get_local_accounts()
+    for acc in accounts:
+        if acc.id == account_id:
+            return acc.serverInfo.url
+    return None

bpy_speckle/connector/utils/get_ascendants.py

@@ -0,0 +1,26 @@
+from typing import Iterator, TypeVar, Type
+from specklepy.objects.base import Base
+from specklepy.objects.graph_traversal.traversal import TraversalContext
+
+
+def get_ascendants(context: TraversalContext) -> Iterator[Base]:
+    """
+    Walks up the tree, returning all ascendants, including context
+    """
+    head = context
+    while head is not None:
+        yield head.current
+        head = head.parent
+
+
+T = TypeVar("T", bound=Base)
+
+
+def get_ascendant_of_type(context: TraversalContext, type_cls: Type[T]) -> Iterator[T]:
+    """
+    Walks up the tree, returning all ascendants of the given type,
+    starting with the context, walking up parent nodes
+    """
+    for ascendant in get_ascendants(context):
+        if isinstance(ascendant, type_cls):
+            yield ascendant

bpy_speckle/connector/utils/misc.py

@@ -0,0 +1,69 @@
+from datetime import datetime, timezone
+
+def format_relative_time(timestamp) -> str:
+    """
+    Convert UTC timestamp to local timezone and return relative time string.
+    
+    Args:
+        timestamp: Either ISO format timestamp string with UTC timezone (ending with 'Z')
+                  or Unix timestamp in milliseconds
+        
+    Returns:
+        str: A human-readable relative time string. Possible formats:
+            - "X minutes ago" (when less than an hour)
+            - "X hours ago" (when less than a day)
+            - "X days ago" (when more than a day)
+            - "Unknown" (when timestamp is None or empty)
+            - "Invalid timestamp" (when parsing fails)
+
+    Note:
+        The function handles timezone conversion automatically, converting UTC
+        timestamps to the local timezone before calculating the relative time.
+    """
+    if not timestamp:
+        return "Unknown"
+        
+    # Convert to local timezone
+    try:
+        # First try parsing as ISO format
+        try:
+            dt = datetime.fromisoformat(str(timestamp).replace('Z', '+00:00'))
+        except ValueError:
+            # If that fails, try parsing as Unix timestamp
+            try:
+                ts = float(timestamp)
+                dt = datetime.fromtimestamp(ts/1000, tz=timezone.utc)
+            except (ValueError, TypeError):
+                return "Invalid timestamp"
+            
+        local_dt = dt.astimezone()  # Convert to local timezone
+        
+        # Calculate relative time
+        now = datetime.now(timezone.utc).astimezone()  # Get current time in local timezone
+        delta = now - local_dt
+        
+        if delta.days == 0:
+            if delta.seconds < 3600:
+                minutes = delta.seconds // 60
+                return f"{minutes} minutes ago"
+            else:
+                hours = delta.seconds // 3600
+                return f"{hours} hours ago"
+        else:
+            return f"{delta.days} days ago"
+    except ValueError:
+        return "Invalid timestamp"
+
+def format_role(role: str) -> str:
+    """
+    This function takes a Speckle role string in the format "prefix:role" and
+    returns just the role part.
+
+    Args:
+        role (str): The role string to format, expected in the format "prefix:role"
+
+    Returns:
+        str: The extracted role name (everything after the colon)
+    """
+    split_role = role.split(":")
+    return f"{split_role[1]}"

bpy_speckle/connector/utils/model_manager.py

@@ -0,0 +1,67 @@
+from specklepy.api.client import SpeckleClient
+from specklepy.api.credentials import get_local_accounts, Account
+from specklepy.core.api.inputs.project_inputs import ProjectModelsFilter
+from specklepy.core.api.models.current import Model
+from typing import List, Tuple, Optional
+from .misc import format_relative_time
+
+def get_models_for_project(account_id: str, project_id: str, search: Optional[str] = None) -> List[Tuple[str, str, str]]:
+    """Fetches models for a given project from the Speckle server.
+
+    This function retrieves a list of models associated with a specific project in a Speckle account.
+    It authenticates with the server using the provided account credentials, validates the project existence,
+    and optionally filters the results based on a search string.
+
+    Args:
+        account_id (str): The unique identifier of the Speckle account.
+        project_id (str): The unique identifier of the project to fetch models from.
+        search (Optional[str], optional): Search string to filter models by name. Defaults to None.
+
+    Returns:
+        List[Tuple[str, str, str]]: A list of tuples where each tuple contains:
+            - model_name (str): The name of the model
+            - model_id (str): The unique identifier of the model
+            - last_updated (str): Relative time since model creation
+
+    Note:
+        Returns an empty list if:
+        - The account_id or project_id are invalid
+        - The account cannot be found
+        - The project cannot be found
+        - Any other error occurs during execution
+        Any errors encountered will be printed with an error message.
+    """
+    try:
+        # Validate inputs
+        if not account_id or not project_id:
+            print(f"Error: Invalid inputs - account_id: {account_id}, project_id: {project_id}")
+            return []
+
+        # Get the account info
+        account: Optional[Account] = next((acc for acc in get_local_accounts() if acc.id == account_id), None)
+        if not account:
+            print(f"Error: Could not find account with ID: {account_id}")
+            return []
+
+        # Initialize the client
+        client = SpeckleClient(host=account.serverInfo.url)
+        # Authenticate
+        client.authenticate_with_account(account)
+
+        # Validate project exists
+        try:
+            client.project.get(project_id)
+        except Exception as e:
+            print(f"Error: Project with ID {project_id} not found: {str(e)}")
+            return []
+
+        filter = ProjectModelsFilter(search=search) if search else None
+
+        # Get models
+        models: List[Model] = client.model.get_models(project_id=project_id, models_limit=10, models_filter=filter).items
+
+        return [(model.name, model.id, format_relative_time(model.updated_at)) for model in models]
+
+    except Exception as e:
+        print(f"Error fetching models: {str(e)}")
+        return []

bpy_speckle/connector/utils/project_manager.py

@@ -0,0 +1,55 @@
+from specklepy.api.client import SpeckleClient
+from specklepy.api.credentials import get_local_accounts
+from specklepy.core.api.inputs.user_inputs import UserProjectsFilter
+from typing import List, Tuple, Optional
+from specklepy.core.api.credentials import Account
+from .misc import format_relative_time, format_role
+
+def get_projects_for_account(account_id: str, search: Optional[str] = None) -> List[Tuple[str, str, str, str]]:
+    """Fetches projects for a given account from the Speckle server.
+    
+    This function retrieves a list of projects associated with a specific Speckle account.
+    It authenticates with the server using the provided account credentials and optionally
+    filters the results based on a search string.
+    
+    Args:
+        account_id (str): The unique identifier of the Speckle account.
+        search (Optional[str], optional): Search string to filter projects by name. Defaults to None.
+    
+    Returns:
+        List[Tuple[str, str, str, str]]: A list of tuples where each tuple contains:
+            - project_name (str): The name of the project
+            - role (str): The user's formatted role in the project
+            - last_updated (str): Relative time since last update
+            - project_id (str): The unique identifier of the project
+            
+    Note:
+        Returns an empty list if the account is not found or if there's an error during execution.
+        Any errors encountered will be printed with their full traceback.
+    """
+    try:
+        # Get the account info
+        accounts: List[Account] = get_local_accounts()
+        account: Optional[Account] = next((acc for acc in accounts if acc.id == account_id), None)
+        if not account:
+            return []
+            
+        # Initialize the client
+        client = SpeckleClient(host=account.serverInfo.url)
+        # Authenticate
+        client.authenticate_with_account(account)
+        
+        # Create filter if search is provided
+        filter = UserProjectsFilter(search=search) if search else None
+        
+        # Fetch projects
+        projects = client.active_user.get_projects(limit=10, filter=filter).items
+        
+        return [(project.name, format_role(project.role), format_relative_time(project.updated_at), project.id) for project in projects]
+        
+    except Exception as e:
+        import traceback
+        error_msg = f"Error: {str(e)}\n"
+        error_msg += f"Traceback:\n{''.join(traceback.format_tb(e.__traceback__))}"
+        print(error_msg)  
+        return []

bpy_speckle/connector/utils/version_manager.py

@@ -0,0 +1,92 @@
+from specklepy.api.client import SpeckleClient
+from specklepy.api.credentials import get_local_accounts, Account
+from typing import List, Tuple, Optional
+from .misc import format_relative_time
+from specklepy.core.api.inputs.model_inputs import ModelVersionsFilter
+from specklepy.core.api.models.current import Version
+
+def get_versions_for_model(account_id: str, project_id: str, model_id: str, search: Optional[str] = None) -> List[Tuple[str, str, str]]:
+    """Fetches versions for a given model from the Speckle server.
+
+    This function retrieves a list of versions associated with a specific model in a Speckle project.
+    It authenticates with the server using the provided account credentials, validates the inputs,
+    and optionally filters the results based on a search string.
+
+    Args:
+        account_id (str): The unique identifier of the account.
+        project_id (str): The unique identifier of the project.
+        model_id (str): The unique identifier of the model to fetch versions from.
+        search (Optional[str], optional): Search string to filter versions by message. Defaults to None.
+
+    Returns:
+        List[Tuple[str, str, str]]: A list of tuples where each tuple contains:
+            - version_id (str): The unique id of the version
+            - message (str): The version message for the version (or "No message" if none provided)
+            - last_updated (str): Relative time since version creation
+
+    Note:
+        Returns an empty list if:
+        - Any of account_id, project_id, or model_id are invalid
+        - The account cannot be found
+        - Any other error occurs during execution
+        Any errors encountered will be printed with an error message.
+    """
+    try:
+        # Validate inputs
+        if not account_id or not project_id or not model_id:
+            print(f"Error: Invalid inputs - account_id: {account_id}, project_id: {project_id}, model_id: {model_id}")
+            return []
+
+        # Get the account info
+        account: Optional[Account] = next((acc for acc in get_local_accounts() if acc.id == account_id), None)
+        if not account:
+            print(f"Error: Could not find account with ID: {account_id}")
+            return []
+
+        # Initialize the client
+        client: SpeckleClient = SpeckleClient(host=account.serverInfo.url)
+        # Authenticate
+        client.authenticate_with_account(account)
+
+        filter: ModelVersionsFilter = ModelVersionsFilter(search=search, priorityIds=[])
+
+        # Get versions
+        versions: List[Version] = client.version.get_versions(project_id=project_id, model_id=model_id, limit=10, filter=filter).items
+
+        return [(version.id, version.message or "No message", format_relative_time(version.created_at)) for version in versions]
+
+    except Exception as e:
+        print(f"Error fetching versions: {str(e)}")
+        return []
+
+def get_latest_version(account_id: str, project_id: str, model_id: str) -> Tuple[str, str, str]:
+    try:
+        # Validate inputs
+        if not account_id or not project_id or not model_id:
+            print(f"Error: Invalid inputs - account_id: {account_id}, project_id: {project_id}, model_id: {model_id}")
+            return ("", "", "")
+
+        # Get the account info
+        account: Optional[Account] = next((acc for acc in get_local_accounts() if acc.id == account_id), None)
+        if not account:
+            print(f"Error: Could not find account with ID: {account_id}")
+            return ("", "", "")
+
+        # Initialize the client
+        client: SpeckleClient = SpeckleClient(host=account.serverInfo.url)
+        # Authenticate
+        client.authenticate_with_account(account)
+
+        # Get versions (limit to 1 since we only need the latest)
+        versions: List[Version] = client.version.get_versions(project_id=project_id, model_id=model_id, limit=1).items
+
+        if not versions:
+            print(f"Error: No versions found for model_id: {model_id}")
+            return ("", "", "")
+
+        latest = versions[0]
+        return (latest.id, latest.message or "No message", format_relative_time(latest.created_at))
+
+    except Exception as e:
+        print(f"Error fetching latest version: {str(e)}")
+        return ("", "", "")

bpy_speckle/convert/constants.py

@@ -1,22 +0,0 @@
-IGNORED_PROPERTY_KEYS = {
-    "id",
-    "elements",
-    "displayMesh",
-    "displayValue",
-    "speckle_type",
-    "parameters",
-    "faces",
-    "colors",
-    "vertices",
-    "renderMaterial",
-    "textureCoordinates",
-    "totalChildrenCount"
-}
-
-DISPLAY_VALUE_PROPERTY_ALIASES = {"displayValue", "@displayValue"}
-ELEMENTS_PROPERTY_ALIASES = {"elements", "@elements"}
-
-OBJECT_NAME_MAX_LENGTH = 62
-SPECKLE_ID_LENGTH = 32
-OBJECT_NAME_SPECKLE_SEPARATOR = " -- "
-OBJECT_NAME_NUMERAL_SEPARATOR = '.'

bpy_speckle/convert/to_native.py

@@ -1,817 +0,0 @@
-import math
-from typing import Any, Dict, Iterable, List, Optional, Sequence, Union, Collection, cast
-from bpy_speckle.convert.constants import DISPLAY_VALUE_PROPERTY_ALIASES, ELEMENTS_PROPERTY_ALIASES, OBJECT_NAME_MAX_LENGTH, OBJECT_NAME_NUMERAL_SEPARATOR, OBJECT_NAME_SPECKLE_SEPARATOR, SPECKLE_ID_LENGTH
-from bpy_speckle.functions import get_default_traversal_func, get_scale_length, _report
-from bpy_speckle.convert.util import ConversionSkippedException
-from mathutils import (
-    Matrix as MMatrix,
-    Vector as MVector,
-    Quaternion as MQuaternion,
-)
-import bpy, bmesh
-from specklepy.objects.other import (
-    Collection as SCollection,
-    Instance,
-    Transform,
-    BlockDefinition,
-)
-from specklepy.objects.base import Base
-from specklepy.objects.geometry import Mesh, Line, Polyline, Curve, Arc, Polycurve, Ellipse, Circle, Plane
-from bpy.types import Object, Collection as BCollection
-
-from .util import (
-    add_to_hierarchy,
-    get_render_material,
-    get_vertex_color_material,
-    render_material_to_native,
-    add_custom_properties,
-    add_vertices,
-    add_faces,
-    add_colors,
-    add_uv_coords,
-)
-
-SUPPORTED_CURVES = (Line, Polyline, Curve, Arc, Polycurve, Ellipse, Circle)
-CAN_CONVERT_TO_NATIVE = (
-
-    Mesh,
-    *SUPPORTED_CURVES,
-    Instance,
-)
-
-
-def _has_native_conversion(speckle_object: Base) -> bool: 
-    return any(isinstance(speckle_object, t) for t in CAN_CONVERT_TO_NATIVE) or "View" in speckle_object.speckle_type #hack
-
-def _has_fallback_conversion(speckle_object: Base) -> bool: 
-    return any(getattr(speckle_object, alias, None) for alias in DISPLAY_VALUE_PROPERTY_ALIASES)
-
-def can_convert_to_native(speckle_object: Base) -> bool:
-
-    if(_has_native_conversion(speckle_object) or _has_fallback_conversion(speckle_object)):
-        return True
-    return False
-
-convert_instances_as: str = "" #HACK: This is hacky, we need a better way to pass settings down to the converter
-def set_convert_instances_as(value: str):
-    global convert_instances_as
-    convert_instances_as = value
-    
-    #TODO: Check usages handle exceptions
-
-def convert_to_native(speckle_object: Base) -> Object:
-
-    speckle_type = type(speckle_object)
-
-    object_name = _generate_object_name(speckle_object)
-    scale = get_scale_factor(speckle_object)
-
-    converted: Union[bpy.types.ID, bpy.types.Object, None] = None
-    children: list[Object] = []
-
-    # convert elements/breps
-    if not _has_native_conversion(speckle_object):
-        (converted, children) = display_value_to_native(speckle_object, object_name, scale)
-        if not converted and not children:
-            raise Exception(f"Zero geometry converted from displayValues for {speckle_object}")
-
-    # convert supported geometry
-    elif isinstance(speckle_object, Mesh):
-        converted = mesh_to_native(speckle_object, object_name, scale)
-    elif speckle_type in SUPPORTED_CURVES:
-        converted = icurve_to_native(speckle_object, object_name, scale)
-    elif "View" in speckle_object.speckle_type:
-         return view_to_native(speckle_object, object_name, scale)
-    elif isinstance(speckle_object, Instance):
-        if convert_instances_as == "linked_duplicates":
-           converted = instance_to_native_object(speckle_object, scale)
-        elif convert_instances_as == "collection_instance":
-            converted = instance_to_native_collection_instance(speckle_object, scale)
-        else:
-            _report(f"convert_instances_as = '{convert_instances_as}' is not implemented, Instances will be converted as collection instances!")
-            converted = instance_to_native_collection_instance(speckle_object, scale)
-    else:
-        raise Exception(f"Unsupported type {speckle_type}")
-
-
-    if not isinstance(converted, Object):
-        converted = create_new_object(converted, object_name)
-    
-    converted.speckle.object_id = str(speckle_object.id) # type: ignore
-    converted.speckle.enabled = True # type: ignore
-    add_custom_properties(speckle_object, converted)
-
-    for c in children:
-        c.parent = converted
-
-    return converted
-
-
-
-def display_value_to_native(speckle_object: Base, name: str, scale: float) -> tuple[Optional[bpy.types.Mesh], list[bpy.types.Object]]:
-    return _members_to_native(speckle_object, name, scale, DISPLAY_VALUE_PROPERTY_ALIASES, True)
-
-def elements_to_native(speckle_object: Base, name: str, scale: float) -> list[bpy.types.Object]:
-    (_, elements) = _members_to_native(speckle_object, name, scale, ELEMENTS_PROPERTY_ALIASES, False)
-    return elements
-
-def _members_to_native(speckle_object: Base, name: str, scale: float, members: Iterable[str], combineMeshes: bool) -> tuple[Optional[bpy.types.Mesh], list[bpy.types.Object]]:
-    """
-    Converts a given speckle_object by converting specified members
-
-    if combineMeshes == True
-        Converts mesh members as one mesh
-        Converts non-mesh members as child Objects
-    if combineMeshes == False
-        Converts all members as child objects (first item of the returned tuple will be None)
-    :returns: converted mesh, and any other converted child objects (may happen if members contained non-meshes)
-    """
-    meshes: list[Mesh] = []
-    others: list[Base] = []
-
-    for alias in members:
-        display = getattr(speckle_object, alias, None)
-
-        count = 0
-        MAX_DEPTH = 255 # some large value, to prevent infinite recursion
-        def separate(value: Any) -> bool:
-            nonlocal meshes, others, count, MAX_DEPTH
-
-            if combineMeshes and isinstance(value, Mesh):
-                meshes.append(value)
-            elif isinstance(value, Base):
-                others.append(value)
-            elif isinstance(value, list):
-                count += 1
-                if(count > MAX_DEPTH):
-                    return True
-                for x in value:
-                    separate(x) 
-
-            return False
-
-        did_halt = separate(display)
-
-        if did_halt:
-            _report(f"Traversal of {speckle_object.speckle_type} {speckle_object.id} halted after traversal depth exceeds MAX_DEPTH={MAX_DEPTH}. Are there circular references object structure?")
-
-
-    children: list[Object] = []
-    mesh = None
-
-    if meshes:
-        mesh = meshes_to_native(speckle_object, meshes, name, scale) #TODO: reconsider passing scale around...
-
-    for item in others:
-        try:
-            blender_object = convert_to_native(item)
-            children.append(blender_object)
-        except Exception as ex:
-            _report(f"Failed to convert display value {item}: {ex}")
-
-    return (mesh, children)
-
-
-
-def view_to_native(speckle_view, name: str, scale: float) -> bpy.types.Object:
-    native_cam: bpy.types.Camera
-    if name in bpy.data.cameras.keys():
-         native_cam = bpy.data.cameras[name]
-    else:
-        native_cam = bpy.data.cameras.new(name=name)
-        native_cam.lens = 18 # 90° horizontal fov
-
-    if not hasattr(speckle_view, "origin"):
-        raise ConversionSkippedException("2D views not supported")
-
-    cam_obj = create_new_object(native_cam, name)
-
-    scale_factor = get_scale_factor(speckle_view, scale)
-    tx = (speckle_view.origin.x * scale_factor)
-    ty = (speckle_view.origin.y * scale_factor)
-    tz = (speckle_view.origin.z * scale_factor)
-
-    forward = MVector((speckle_view.forwardDirection.x, speckle_view.forwardDirection.y, speckle_view.forwardDirection.z))
-    up = MVector((speckle_view.upDirection.x, speckle_view.upDirection.y, speckle_view.upDirection.z))
-    right = forward.cross(up).normalized()
-
-    cam_obj.matrix_world = MMatrix((
-        (right.x,  up.x,  -forward.x, tx),
-        (right.y,  up.y,  -forward.y, ty),
-        (right.z,  up.z,  -forward.z, tz),
-        (0,          0,     0,       1 )
-    ))
-    return cam_obj
-
-def mesh_to_native(speckle_mesh: Mesh, name: str, scale: float) -> bpy.types.Mesh:
-    return meshes_to_native(speckle_mesh, [speckle_mesh], name, scale)
-
-
-
-def meshes_to_native(element: Base, meshes: Collection[Mesh], name: str, scale: float) -> bpy.types.Mesh:
-    if name in bpy.data.meshes.keys():
-        return bpy.data.meshes[name]
-    blender_mesh = bpy.data.meshes.new(name=name)
-
-    fallback_material = get_render_material(element)
-
-    bm = bmesh.new()
-
-    # First pass, add vertex data
-    for mesh in meshes:
-        scale = get_scale_factor(mesh, scale)
-        add_vertices(mesh, bm, scale)
-
-    bm.verts.ensure_lookup_table()
-
-    # Second pass, add face data
-    offset = 0
-    for i, mesh in enumerate(meshes):
-        if not mesh.vertices: continue
-
-        add_faces(mesh, bm, offset, i)
-
-        try:
-            render_material = get_render_material(mesh) or fallback_material
-            if render_material is not None:
-                native_material = render_material_to_native(render_material)
-                blender_mesh.materials.append(native_material)
-            elif mesh.colors:
-                native_material = get_vertex_color_material()
-                blender_mesh.materials.append(native_material)
-        except Exception as ex:
-            _report(f"Failed converting render material for {name}: {ex}")
-
-        offset += len(mesh.vertices) // 3
-
-    bm.faces.ensure_lookup_table()
-    bm.verts.index_update()
-
-    # Third pass, add vertex instance data
-    for mesh in meshes:
-        try:
-            add_colors(mesh, bm)
-        except Exception as ex:
-            _report(f"Skipping converting vertex colors for {name}: {ex}")
-            
-        try:
-            add_uv_coords(mesh, bm)
-        except Exception as ex:
-            _report(f"Skipping converting uv coordinates for {name}: {ex}")
-
-    bm.to_mesh(blender_mesh)
-    bm.free()  
-
-    return blender_mesh
-
-
-"""
-Curves
-"""
-
-def line_to_native(speckle_curve: Line, blender_curve: bpy.types.Curve, scale: float) -> List[bpy.types.Spline]:
-    if not speckle_curve.end: return []
-
-    line = blender_curve.splines.new("POLY")
-    line.points.add(1)
-
-    line.points[0].co = (
-        float(speckle_curve.start.x) * scale,
-        float(speckle_curve.start.y) * scale,
-        float(speckle_curve.start.z) * scale,
-        1,
-    )
-
-    line.points[1].co = (
-        float(speckle_curve.end.x) * scale,
-        float(speckle_curve.end.y) * scale,
-        float(speckle_curve.end.z) * scale,
-        1,
-    )
-
-    return [line]
-
-
-def polyline_to_native(scurve: Polyline, bcurve: bpy.types.Curve, scale: float) -> List[bpy.types.Spline]:
-    if not (value := scurve.value): return []
-    N = len(value) // 3
-
-    polyline = bcurve.splines.new("POLY")
-
-    if hasattr(scurve, "closed"):
-        polyline.use_cyclic_u = scurve.closed or False
-
-    polyline.points.add(N - 1)
-    for i in range(N):
-        polyline.points[i].co = (
-            float(value[i * 3]) * scale,
-            float(value[i * 3 + 1]) * scale,
-            float(value[i * 3 + 2]) * scale,
-            1,
-        )
-
-    return [polyline]
-    
-
-
-def nurbs_to_native(scurve: Curve, bcurve: bpy.types.Curve, scale: float) -> List[bpy.types.Spline]:
-    if not (points := scurve.points): return []
-    if not scurve.degree: raise Exception("curve is missing degree")
-    if not scurve.weights: raise Exception("curve is missing weights")
-
-    # Closed curves from rhino will have n + degree points. We ignore the extras
-    num_points = len(points) // 3 - scurve.degree if (scurve.closed) else (
-        len(points) // 3)   
-    
-    nurbs = bcurve.splines.new("NURBS")
-    nurbs.use_cyclic_u = scurve.closed or False
-    nurbs.use_endpoint_u = not scurve.periodic
-    
-    nurbs.points.add(num_points - 1)
-    use_weights = len(scurve.weights) >= num_points
-    for i in range(num_points):
-        nurbs.points[i].co = (
-            float(points[i * 3]) * scale,
-            float(points[i * 3 + 1]) * scale,
-            float(points[i * 3 + 2]) * scale,
-            1,
-        )
-        
-        nurbs.points[i].weight = scurve.weights[i] if use_weights else 1
-
-    nurbs.order_u = scurve.degree + 1
-
-    return [nurbs]
-
-
-def arc_to_native(rcurve: Arc, bcurve: bpy.types.Curve, scale: float) -> Optional[bpy.types.Spline]:
-    # TODO: improve Blender representation of arc - check autocad test stream
-    if not rcurve.radius: raise Exception("curve is missing radius")
-    if not rcurve.startAngle: raise Exception("curve is missing startAngle")
-    if not rcurve.endAngle: raise Exception("curve is missing endAngle")
-
-    plane = rcurve.plane
-    if not plane:
-        return None
-
-    normal = MVector([plane.normal.x, plane.normal.y, plane.normal.z])
-
-    radius = rcurve.radius * scale
-    startAngle = rcurve.startAngle
-    endAngle = rcurve.endAngle
-
-    startQuat = MQuaternion(normal, startAngle) # type: ignore
-    endQuat = MQuaternion(normal, endAngle) # type: ignore
-
-    # Get start and end vectors, centre point, angles, etc.
-    r1 = MVector([plane.xdir.x, plane.xdir.y, plane.xdir.z])
-    r1.rotate(startQuat)
-
-    r2 = MVector([plane.xdir.x, plane.xdir.y, plane.xdir.z])
-    r2.rotate(endQuat)
-
-    c = MVector([plane.origin.x, plane.origin.y, plane.origin.z]) * scale
-
-    spt = c + r1 * radius
-    ept = c + r2 * radius
-
-    angle = endAngle - startAngle
-
-    t1 = normal.cross(r1)
-
-    # Initialize arc data and calculate subdivisions
-    arc = bcurve.splines.new("NURBS")
-
-    arc.use_cyclic_u = False
-
-    Ndiv = max(int(math.floor(angle / 0.3)), 2)
-    step = angle / float(Ndiv)
-    stepQuat = MQuaternion(normal, step) # type: ignore
-    tan = math.tan(step / 2) * radius
-
-    arc.points.add(Ndiv + 1)
-
-    # Set start and end points
-    arc.points[0].co = (spt.x, spt.y, spt.z, 1)
-    arc.points[Ndiv + 1].co = (ept.x, ept.y, ept.z, 1)
-
-    # Set intermediate points
-    for i in range(Ndiv):
-        t1 = normal.cross(r1)
-        pt = c + r1 * radius + t1 * tan
-        arc.points[i + 1].co = (pt.x, pt.y, pt.z, 1)
-        r1.rotate(stepQuat)
-
-    # Set curve settings
-    arc.use_endpoint_u = True
-    arc.order_u = 3
-
-    return arc
-
-
-def polycurve_to_native(scurve: Polycurve, bcurve: bpy.types.Curve, scale: float) -> list[bpy.types.Spline]:
-    """
-    Convert Polycurve object
-    """
-    if not scurve.segments: raise Exception("curve is missing segments")
-
-    curves = []
-
-    for seg in scurve.segments:
-        speckle_type = type(seg)
-
-        if speckle_type in SUPPORTED_CURVES:
-            curves.append(icurve_to_native_spline(seg, bcurve, scale))
-        else:
-            _report(f"Unsupported curve type: {speckle_type}")
-
-    return curves
- 
-def ellipse_to_native(ellipse: Union[Ellipse, Circle], bcurve: bpy.types.Curve, units_scale: float) -> List[bpy.types.Spline]:
-    if not ellipse.plane: raise Exception("curve is missing plane")
-
-    radX: float
-    radY: float
-    if isinstance(ellipse, Ellipse):
-        if not ellipse.firstRadius: raise Exception("curve is missing firstRadius")
-        if not ellipse.secondRadius: raise Exception("curve is missing secondRadius")
-
-        radX = ellipse.firstRadius * units_scale
-        radY = ellipse.secondRadius * units_scale
-    else:
-        if not ellipse.radius: raise Exception("curve is missing radius")
-
-        radX = ellipse.radius * units_scale
-        radY = ellipse.radius * units_scale
-
-    
-    D = 0.5522847498307936 # (4/3)*tan(pi/8)
-
-    right_handles = [
-        (+radX,     +radY * D,  0.0),
-        (-radX * D, +radY,      0.0),
-        (-radX,     -radY * D,  0.0),
-        (+radX * D, -radY,      0.0),
-    ]
-
-    left_handles = [
-        (+radX,     -radY * D,  0.0),
-        (+radX * D, +radY,      0.0),
-        (-radX,     +radY * D,  0.0),
-        (-radX * D, -radY,      0.0),
-    ]
-
-    points = [
-        (+radX, 0.0,   0.0),
-        (0.0,   +radY, 0.0),
-        (-radX, 0.0,   0.0),
-        (0.0,   -radY, 0.0),
-    ]
-    transform = plane_to_native_transform(ellipse.plane, units_scale)
-
-    spline = bcurve.splines.new("BEZIER")
-    spline.bezier_points.add(len(points) - 1)
-
-    for i in range(len(points)):
-        spline.bezier_points[i].co = transform @ MVector(points[i]) # type: ignore
-        spline.bezier_points[i].handle_left = transform @ MVector(left_handles[i]) # type: ignore
-        spline.bezier_points[i].handle_right = transform @ MVector(right_handles[i]) # type: ignore
-
-    spline.use_cyclic_u = True
-    
-    #TODO support trims?
-    return [spline]
-
-
-def icurve_to_native_spline(speckle_curve: Base, blender_curve: bpy.types.Curve, scale: float) -> List[bpy.types.Spline]:
-    # polycurves
-    if isinstance(speckle_curve, Polycurve):
-        return polycurve_to_native(speckle_curve, blender_curve, scale)
-
-    splines: List[bpy.types.Spline]
-    # single curves
-    if isinstance(speckle_curve, Line):
-        splines = line_to_native(speckle_curve, blender_curve, scale)
-    elif isinstance(speckle_curve, Curve):
-        splines = nurbs_to_native(speckle_curve, blender_curve, scale)
-    elif isinstance(speckle_curve, Polyline):
-        splines = polyline_to_native(speckle_curve, blender_curve, scale)
-    elif isinstance(speckle_curve, Arc):
-        spline = arc_to_native(speckle_curve, blender_curve, scale)
-        splines = [spline] if spline else []
-    elif isinstance(speckle_curve, Ellipse) or isinstance(speckle_curve, Circle):
-        splines = ellipse_to_native(speckle_curve, blender_curve, scale)
-    else:
-        raise TypeError(f"{speckle_curve} is not a supported curve type. Supported types: {SUPPORTED_CURVES}")
-
-    return splines
-
-
-def icurve_to_native(speckle_curve: Base, name: str, scale: float) -> bpy.types.Curve:
-    curve_type = type(speckle_curve)
-    if curve_type not in SUPPORTED_CURVES:
-        raise Exception(f"Unsupported curve type: {curve_type}")
-
-    blender_curve = (
-        bpy.data.curves[name]
-        if name in bpy.data.curves.keys()
-        else bpy.data.curves.new(name, type="CURVE")
-    )
-    blender_curve.dimensions = "3D"
-    blender_curve.resolution_u = 12 #TODO: We could maybe decern the resolution from the polyline displayValue
-
-    icurve_to_native_spline(speckle_curve, blender_curve, scale)
-
-    return blender_curve
-
-
-"""
-Transforms and Instances
-"""
-
-def transform_to_native(transform: Transform, scale: float) -> MMatrix:
-    mat = MMatrix(
-        [
-            transform.value[:4],
-            transform.value[4:8],
-            transform.value[8:12],
-            transform.value[12:16],
-        ]
-    )
-    # scale the translation
-    for i in range(3):
-        mat[i][3] *= scale
-    return mat
-
-def plane_to_native_transform(plane: Plane, fallback_scale:float = 1) -> MMatrix:
-    scale_factor = get_scale_factor(plane, fallback_scale)
-    tx = (plane.origin.x * scale_factor)
-    ty = (plane.origin.y * scale_factor)
-    tz = (plane.origin.z * scale_factor)
-
-
-    return MMatrix((
-        (plane.xdir.x,  plane.ydir.x,  plane.normal.x, tx),
-        (plane.xdir.y,  plane.ydir.y,  plane.normal.y, ty),
-        (plane.xdir.z,  plane.ydir.z,  plane.normal.z, tz),
-        (0,             0,             0,              1 )
-    ))
-
-
-"""
-Instances / Blocks
-"""
-
-def _get_instance_name(instance: Instance) -> str:
-    if not instance.definition: raise Exception("Instance is missing a definition")
-    name_prefix = (
-        _get_friendly_object_name(instance) 
-        or _get_friendly_object_name(instance.definition) 
-        or _simplified_speckle_type(instance.speckle_type)
-    )
-    return f"{name_prefix}{OBJECT_NAME_SPECKLE_SEPARATOR}{instance.id}"
-
-
-def instance_to_native_object(instance: Instance, scale: float) -> Object:
-    """
-    Converts Instance to a unique object with (potentially) shared data (linked duplicate)
-    """
-    if not instance.definition: raise Exception("Instance is missing a definition")
-    if not instance.transform: raise Exception("Instance is missing a transform")
-    definition = instance.definition
-    if not definition.id: raise Exception("Instance is missing a valid definition")
-
-    name = _get_instance_name(instance)
-
-    native_instance: Optional[Object] = None
-    converted_objects: Dict[str, Union[Object, BCollection]] = {}
-    traversal_root: Base = definition
-    
-    if not can_convert_to_native(definition):
-        # Non-convertible (like all blocks, and some revit instances) will not be converted as part of the deep_traversal.
-        # so we explicitly convert them as empties.
-        native_instance = create_new_object(None, name) 
-        native_instance.empty_display_size = 0
-
-        converted_objects["__ROOT"] = native_instance # we create a dummy root to avoid id conflicts, since revit definitions have displayValues, they are convertible
-        traversal_root = Base(elements=definition, id="__ROOT")
-
-    #Convert definition + "elements" on definition
-    _deep_conversion(traversal_root, converted_objects, False)
-
-    if not native_instance:
-        assert(can_convert_to_native(definition))
-
-        if not definition.id in converted_objects:
-            raise Exception("Definition was not converted")
-
-        converted = converted_objects[definition.id]
-
-        if not isinstance(converted, Object):
-            raise Exception("Definition was not converted to an Object")
-        
-        native_instance = converted
-
-    instance_transform = transform_to_native(instance.transform, scale)
-    native_instance.matrix_world = instance_transform
-
-    return native_instance
-
-def instance_to_native_collection_instance(instance: Instance, scale: float) -> bpy.types.Object:
-    """
-    Convert an Instance as a transformed Object with the `instance_collection` property
-    set to be the `instance.Definition` converted as a collection
-
-    The definition collection won't be linked to the current scene
-    Any Elements on the instance object will also be converted (and spacially transformed)
-    """
-    if not instance.definition: raise Exception("Instance is missing a definition")
-    if not instance.transform: raise Exception("Instance is missing a transform")
-
-    name = _get_instance_name(instance)
-
-    # Get/Convert definition collection
-    collection_def = _instance_definition_to_native(instance.definition)
-
-    instance_transform = transform_to_native(instance.transform, scale)
-
-    native_instance = create_new_object(None, name)
-
-    #add_custom_properties(instance, native_instance)
-    # hide the instance axes so they don't clutter the viewport
-    native_instance.empty_display_size = 0
-    native_instance.instance_collection = collection_def
-    native_instance.instance_type = "COLLECTION"
-    native_instance.matrix_world = instance_transform
-        
-    return native_instance 
-
-def _instance_definition_to_native(definition: Union[Base, BlockDefinition]) -> bpy.types.Collection:
-    """
-    Converts a geometry carrying Base as a collection (does not link it to the scene)
-    """
-    name = _generate_object_name(definition)
-    native_def = bpy.data.collections.get(name)
-    if native_def:
-        return native_def
-
-    native_def = create_new_collection(name)
-    native_def["applicationId"] = definition.applicationId
-
-    converted_objects = {}
-    converted_objects["__ROOT"] = native_def # we create a dummy root to avoid id conflicts, since revit definitions have displayValues, they are convertible
-    dummyRoot = Base(elements=definition, id="__ROOT")
-
-    _deep_conversion(dummyRoot, converted_objects, True)
-
-    return native_def
-
-def _deep_conversion(root: Base, converted_objects: Dict[str, Union[Object, BCollection]], preserve_transform: bool):
-    traversal_func = get_default_traversal_func(can_convert_to_native)
-
-    for item in traversal_func.traverse(root):
-        
-        current: Base = item.current
-        if can_convert_to_native(current) or isinstance(current, SCollection):
-            try:
-                if not current or not current.id: raise Exception(f"{current} was an invalid speckle object")
-
-                #Convert the object!
-                converted_data_type: str
-                converted: Union[Object, BCollection, None]
-                if isinstance(current, SCollection):
-                    if(current.collectionType == "Scene Collection"): raise ConversionSkippedException()
-                    converted = collection_to_native(current)
-                    converted_data_type = "COLLECTION"
-                else:
-                    converted = convert_to_native(current)
-                    converted_data_type = "COLLECTION_INSTANCE" if converted.instance_collection else str(converted.type)
-                
-                if converted is None:
-                    raise Exception("Conversion returned None")
-                    
-                converted_objects[current.id] = converted
-
-                add_to_hierarchy(converted, item, converted_objects, preserve_transform)
-
-                _report(f"Successfully converted {type(current).__name__} {current.id} as '{converted_data_type}'")
-            except ConversionSkippedException as ex:
-                _report(f"Skipped converting {type(current).__name__} {current.id}: {ex}")
-            except Exception as ex:
-                _report(f"Failed to converted {type(current).__name__} {current.id}: {ex}")
-
-def collection_to_native(collection: SCollection) -> BCollection: 
-    name = collection.name or f"{collection.collectionType} -- {collection.applicationId or collection.id}"  #TODO: consider consolidating name formatting with Rhino
-    ret =  get_or_create_collection(name)
-
-    color = getattr(collection, "colorTag", None)
-    if color:
-        ret.color_tag = color
-
-    return ret
-
-def get_or_create_collection(name: str, clear_collection: bool = True) -> BCollection:
-    #Disabled for now, since update mode needs rescoping.
-    # existing = cast(Optional[BCollection], bpy.data.collections.get(name))
-    # if existing:
-    #     if clear_collection:
-    #         for obj in existing.objects:
-    #             existing.objects.unlink(obj)
-    #     return existing
-    # else:
-    new_collection = create_new_collection(name)
-
-    #NOTE: We want to not render revit "Rooms" collections by default.
-    if name == "Rooms":
-        new_collection.hide_viewport = True
-        new_collection.hide_render = True
-
-    return new_collection
-    
-    
-
-"""
-Object Naming and Creation
-"""
-
-def create_new_collection( desired_name: str) -> bpy.types.Collection:
-    """
-    Creates a new blender collection with a unique name
-    If the desired_name is already taken
-    we'll append a number, with the format .xxx to the desired_name to ensure the name is unique.
-    """
-    name = _make_unique_name(desired_name, bpy.data.collections.keys())
-
-    blender_collection = bpy.data.collections.new(name)
-    return blender_collection
-
-def create_new_object(obj_data: Optional[bpy.types.ID], desired_name: str) -> bpy.types.Object:
-    """
-    Creates a new blender object with a unique name,
-    If the desired_name is already taken
-    we'll append a number, with the format .xxx to the desired_name to ensure the name is unique.
-    """
-    name = _make_unique_name(desired_name, bpy.data.objects.keys())
-
-    blender_object = bpy.data.objects.new(name, obj_data)
-    return blender_object
-
-def _make_unique_name( desired_name: str, taken_names: Collection[str], counter: int = 0) -> str:
-    """
-    Using Blenders default naming (append numeral in .xxx format) to avoid name conflicts with taken names
-    """
-    name = desired_name if counter == 0 else f"{desired_name[:OBJECT_NAME_MAX_LENGTH - 4]}{OBJECT_NAME_NUMERAL_SEPARATOR}{counter:03d}"  # format counter as name.xxx, truncate to ensure we don't exceed the object name max length
-
-    #TODO: This is very slow, and gets slower the more objects you receive with the same name...
-    # We could use a binary/galloping search, and/or cache the name -> index within a receive.
-    if name in taken_names:
-        #Name already taken, increment counter and try again!
-        return _make_unique_name(desired_name, taken_names, counter + 1)
-
-    return name
-
-
-def _get_friendly_object_name(speckle_object: Base) -> Optional[str]:
-    return (getattr(speckle_object, "name", None)
-        or getattr(speckle_object, "Name", None)
-        or _get_revit_family_name(speckle_object)
-        )
-
-def _get_revit_family_name(speckle_object: Base) -> Optional[str]:
-    family = getattr(speckle_object, "family", None)
-    family_type = getattr(speckle_object, "type", None)
-
-    if family and family_type:
-        return f"{family_type}-{family}"
-    else:
-        return None
-
-# Blender object names must not exceed 62 characters
-# We need to ensure the complete ID is included in the name (to prevent identity collisions)
-# So we if the name is too long, we need to truncate
-def _truncate_object_name(name: str) -> str:
-
-    MAX_NAME_LENGTH = OBJECT_NAME_MAX_LENGTH - SPECKLE_ID_LENGTH - len(OBJECT_NAME_SPECKLE_SEPARATOR)
-
-    return name[:MAX_NAME_LENGTH]
-    
-
-def _simplified_speckle_type(speckle_type: str) -> str:
-    return(speckle_type.rsplit('.')[-1]) #Take only the most specific object type name (without namespace)
-
-def _generate_object_name(speckle_object: Base) -> str:
-    prefix: str
-    name = _get_friendly_object_name(speckle_object)
-    if name:
-        prefix = _truncate_object_name(name)
-    else:
-        prefix = _simplified_speckle_type(speckle_object.speckle_type)
-
-    return f"{prefix}{OBJECT_NAME_SPECKLE_SEPARATOR}{speckle_object.id}"
-
-
-def get_scale_factor(speckle_object: Base, fallback: float = 1.0) -> float:
-    scale = fallback
-    if units := getattr(speckle_object, "units", None):
-        scale = get_scale_length(units) / bpy.context.scene.unit_settings.scale_length
-    return scale

bpy_speckle/convert/to_speckle.py

@@ -1,541 +0,0 @@
-from typing import Dict, Iterable, List, Optional, Tuple, Union, cast
-import bpy
-from bpy.types import (
-    Depsgraph, 
-    MeshPolygon, 
-    Object, 
-    Curve as NCurve,
-    Mesh as NMesh,
-    Camera as NCamera,
-)
-from deprecated import deprecated
-from mathutils.geometry import interpolate_bezier
-from mathutils import (
-    Matrix as MMatrix,
-    Vector as MVector,
-)
-from specklepy.objects import Base
-from specklepy.objects.other import BlockInstance, BlockDefinition, RenderMaterial, Transform
-from specklepy.objects.geometry import (
-     Mesh, Curve, Interval, Box, Point, Vector, Polyline,
-)
-from bpy_speckle.blender_commit_object_builder import BlenderCommitObjectBuilder
-from bpy_speckle.convert.constants import OBJECT_NAME_SPECKLE_SEPARATOR, SPECKLE_ID_LENGTH
-from bpy_speckle.convert.util import (
-    ConversionSkippedException,
-    get_blender_custom_properties,
-    make_knots,
-    nurb_make_curve,
-    to_argb_int,
-)
-from bpy_speckle.functions import _report
-
-
-Units: str = "m" # The desired final units to send
-UnitsScale: float = 1 # The scale factor conversions need to apply to position data to get to the desired units
-
-CAN_CONVERT_TO_SPECKLE = ("MESH", "CURVE", "EMPTY", "CAMERA", "FONT", "SURFACE", "META")
-
-
-def convert_to_speckle(raw_blender_object: Object, units_scale: float, units: str, depsgraph: Optional[Depsgraph]) -> Base:
-    """
-    Converts supported 1 blender objects to 1 speckle object (potentially with children)
-    :param raw_blender_object: the blender object (unevaluated by a Depsgraph) to convert
-    :param units_scale: The scale factor conversions need to apply to position data to get to the desired units
-    :param units: The desired final units to send
-    :param depsgraph: Optional depsgraph if provided will evaluate modifiers on geometry data
-    :return: The Converted blender object
-    """
-    global Units, UnitsScale
-    Units = units
-    UnitsScale = units_scale
-    
-    blender_type = raw_blender_object.type
-    if blender_type not in CAN_CONVERT_TO_SPECKLE:
-        raise ConversionSkippedException(f"Objects of type {blender_type} are not supported")
-
-    blender_object = cast(Object, (
-        raw_blender_object.evaluated_get(depsgraph)
-        if depsgraph
-        else raw_blender_object
-        ))
-
-    converted: Optional[Base] = None
-    if blender_type == "MESH":
-        converted = mesh_to_speckle(blender_object, cast(NMesh, blender_object.data))
-    elif blender_type == "CURVE":
-        converted = curve_to_speckle(blender_object, cast(NCurve, blender_object.data))
-    elif blender_type == "EMPTY":
-        converted = empty_to_speckle(blender_object)
-    elif blender_type == "CAMERA":
-        converted = camera_to_speckle_view(blender_object, cast(NCamera, blender_object.data))
-    elif blender_type == "FONT" or "SURFACE" or "META":
-        converted = anything_to_speckle_mesh(blender_object)
-    if not converted:
-        raise Exception("Conversion returned None")
-
-    converted["properties"] = get_blender_custom_properties(raw_blender_object) #NOTE: Depsgraph copies don't have custom properties so we use the raw version
-
-    # Set object transform #TODO: this could be deprecated once we add proper geometry instancing support
-    if blender_type != "EMPTY": 
-        converted["properties"]["transform"] = transform_to_speckle(
-            blender_object.matrix_world
-        )
-
-    return converted
-
-def mesh_to_speckle(blender_object: Object, data: bpy.types.Mesh) -> Base:
-    b = Base()
-    b["name"] = to_speckle_name(blender_object)
-    b["@displayValue"] = mesh_to_speckle_meshes(blender_object, data)
-    return b
-
-def mesh_to_speckle_meshes(blender_object: Object, data: bpy.types.Mesh) -> List[Mesh]:
-
-    # Categorise polygons by material index
-    submesh_data: Dict[int, List[MeshPolygon]] = {}
-
-    for p in data.polygons:
-        if p.material_index not in submesh_data:
-            submesh_data[p.material_index] = []
-        submesh_data[p.material_index].append(p)
-
-    transform = cast(MMatrix, blender_object.matrix_world)
-    scaled_vertices = [tuple(transform @ x.co * UnitsScale) for x in data.vertices] 
-
-    # Create Speckle meshes for each material
-    submeshes = []
-    index_counter = 0
-    for i in submesh_data:
-        index_mapping: Dict[int, int] = {}
-
-        #Loop through each polygon, and map indices to their new index in m_verts
-    
-        mesh_area = 0
-        m_verts: List[float] = []
-        m_faces: List[int] = []
-        m_texcoords: List[float] = []
-        for face in submesh_data[i]:
-            u_indices = face.vertices
-            m_faces.append(len(u_indices))
-
-            mesh_area += face.area
-            for u_index in u_indices:
-                if u_index not in index_mapping:
-                    # Create mapping between index in blender mesh, and new index in speckle submesh
-                    index_mapping[u_index] = len(m_verts) // 3
-                    vert = scaled_vertices[u_index]
-                    m_verts.append(vert[0])
-                    m_verts.append(vert[1])
-                    m_verts.append(vert[2])
-                
-                if data.uv_layers.active:
-                    vt = data.uv_layers.active.data[index_counter]
-                    uv = cast(MVector, vt.uv)
-                    m_texcoords.extend([uv.x, uv.y])
-
-                m_faces.append(index_mapping[u_index])
-                index_counter += 1
-
-        speckle_mesh = Mesh(
-            vertices=m_verts,
-            faces=m_faces,
-            colors=[],
-            textureCoordinates=m_texcoords,
-            units=Units,
-            area = mesh_area,
-            bbox=Box(area=0.0, volume=0.0),
-        )
-        
-        if i < len(data.materials):
-            material = data.materials[i]
-            if material is not None:
-                speckle_mesh["renderMaterial"] = material_to_speckle(material)
-        submeshes.append(speckle_mesh)           
-
-    return submeshes
-
-
-def bezier_to_speckle(matrix: MMatrix, spline: bpy.types.Spline, name: Optional[str] = None) -> Curve:
-    degree = 3
-    closed = spline.use_cyclic_u
-    points: List[Tuple[MVector]] = []
-    for i, bp in enumerate(spline.bezier_points):
-        if i > 0:
-            points.append(tuple(matrix @ bp.handle_left * UnitsScale)) # type: ignore
-        points.append(tuple(matrix @ bp.co * UnitsScale)) # type: ignore
-        if i < len(spline.bezier_points) - 1:
-            points.append(tuple(matrix @ bp.handle_right * UnitsScale)) # type: ignore
-
-    if closed:
-        points.extend(
-            (
-                tuple(matrix @ spline.bezier_points[-1].handle_right * UnitsScale), # type: ignore
-                tuple(matrix @ spline.bezier_points[0].handle_left * UnitsScale), # type: ignore
-                tuple(matrix @ spline.bezier_points[0].co * UnitsScale), # type: ignore
-            )
-        )
-    
-    num_points = len(points)
-
-    flattened_points = []
-    for row in points: flattened_points.extend(row)
-
-    knot_count = num_points + degree - 1
-    knots = [0] * knot_count
-
-    for i in range(1, len(knots)):
-        knots[i] = i // 3
-
-    length = spline.calc_length()
-    domain = Interval(start=0, end=length, totalChildrenCount=0)
-    return Curve(
-        name=name,
-        degree=degree,
-        closed=spline.use_cyclic_u,
-        periodic= not spline.use_endpoint_u,
-        points=flattened_points,
-        weights=[1] * num_points,
-        knots=knots,
-        rational=True,
-        area=0,
-        volume=0,
-        length=length,
-        domain=domain,
-        units=Units,
-        bbox=Box(area=0.0, volume=0.0),
-        displayValue = bezier_to_speckle_polyline(matrix, spline, length),
-    )
-
-
-def nurbs_to_speckle(matrix: MMatrix, spline: bpy.types.Spline, name: Optional[str] = None) -> Curve:
-
-    degree = spline.order_u - 1
-    knots = make_knots(spline)
-
-    length = spline.calc_length()
-    domain = Interval(start=0, end=length, totalChildrenCount=0)
-
-    weights = [pt.weight for pt in spline.points]
-    is_rational = all(w == weights[0] for w in weights)
-
-    points = [tuple(matrix @ pt.co.xyz * UnitsScale) for pt in spline.points] # type: ignore
-
-    flattened_points = []
-    for row in points: flattened_points.extend(row)
-
-    if spline.use_cyclic_u:
-        for i in range(0, degree * 3, 3):
-            # Rhino expects n + degree number of points (for closed curves). So we need to add an extra point for each degree
-            flattened_points.append(flattened_points[i + 0])
-            flattened_points.append(flattened_points[i + 1])
-            flattened_points.append(flattened_points[i + 2])
-        
-        for i in range(0, degree):
-            weights.append(weights[i])
-
-    return Curve(
-        name=name,
-        degree=degree,
-        closed=spline.use_cyclic_u,
-        periodic= not spline.use_endpoint_u,
-        points=flattened_points,
-        weights=weights,
-        knots=knots,
-        rational=is_rational, 
-        area=0,
-        volume=0,
-        length=length,
-        domain=domain,
-        units=Units,
-        bbox=Box(area=0.0, volume=0.0),
-        displayValue=nurbs_to_speckle_polyline(matrix, spline, length),
-    )
-
-def nurbs_to_speckle_polyline(matrix: MMatrix, spline: bpy.types.Spline, length: Optional[float] = None) -> Polyline:
-    """
-    Samples a nurbs curve with resolution_u creating a polyline
-    """
-    points: List[float] = []
-    sampled_points = nurb_make_curve(spline, spline.resolution_u, 3)
-    for i in range(0, len(sampled_points), 3):
-        scaled_point = cast(Vector, matrix @ MVector((
-        sampled_points[i + 0],
-        sampled_points[i + 1],
-        sampled_points[i + 2])) * UnitsScale)
-
-        points.append(scaled_point.x)
-        points.append(scaled_point.y)
-        points.append(scaled_point.z)
-        
-    length = length or spline.calc_length()
-    domain = Interval(start=0, end=length, totalChildrenCount=0)
-    return Polyline(value=points, closed = spline.use_cyclic_u, domain=domain, area=0, len=length)
-
-
-#Inspired by https://blender.stackexchange.com/a/689 (CC BY-SA 3.0) 
-def bezier_to_speckle_polyline(matrix: MMatrix, spline: bpy.types.Spline, length: Optional[float] = None) -> Optional[Polyline]:
-    """
-    Samples a Bézier curve with resolution_u creating a polyline
-    """
-    segments = len(spline.bezier_points)
-    if segments < 2: return None
-
-    R = spline.resolution_u + 1
-
-    points = []
-    if not spline.use_cyclic_u:
-        segments -= 1
-    
-    points: List[float] = []
-    for i in range(segments):
-        inext = (i + 1) % len(spline.bezier_points)
-
-        knot1 = spline.bezier_points[i].co
-        handle1 = spline.bezier_points[i].handle_right
-        handle2 = spline.bezier_points[inext].handle_left
-        knot2 = spline.bezier_points[inext].co
-
-        _points = interpolate_bezier(knot1, handle1, handle2, knot2, R)
-        for p in _points:
-            scaled_point = matrix @ p * UnitsScale
-            points.append(scaled_point.x)
-            points.append(scaled_point.y)
-            points.append(scaled_point.z)
-
-    length = length or spline.calc_length()
-    domain = Interval(start=0, end=length, totalChildrenCount=0)
-    return Polyline(value=points, closed = spline.use_cyclic_u, domain=domain, area=0, len=length)
-
-_QUICK_TEST_NAME_LENGTH = SPECKLE_ID_LENGTH + len(OBJECT_NAME_SPECKLE_SEPARATOR)
-
-def to_speckle_name(blender_object: bpy.types.ID) -> str:
-    does_name_contain_id = len(blender_object.name) > _QUICK_TEST_NAME_LENGTH and OBJECT_NAME_SPECKLE_SEPARATOR in blender_object.name
-    if does_name_contain_id:
-        return blender_object.name.rsplit(OBJECT_NAME_SPECKLE_SEPARATOR, 1)[0]
-    else:
-        return blender_object.name
-
-def poly_to_speckle(matrix: MMatrix, spline: bpy.types.Spline, name: Optional[str] = None) -> Polyline:
-    points = [tuple(matrix @ pt.co.xyz * UnitsScale) for pt in spline.points] # type: ignore
-
-    flattened_points = []
-    for row in points: flattened_points.extend(row)
-
-    length = spline.calc_length()
-    domain = Interval(start=0, end=length, totalChildrenCount=0)
-    return Polyline(
-        name=name,
-        closed=bool(spline.use_cyclic_u),
-        value=list(flattened_points),
-        length=length,
-        domain=domain,
-        bbox=Box(area=0.0, volume=0.0),
-        area=0,
-        units=Units,
-    )
-
-
-def curve_to_speckle(blender_object: Object, data: bpy.types.Curve) -> Base:
-    b = Base()
-    (meshes, curves) = curve_to_speckle_geometry(blender_object, data)
-    if meshes:
-        b["@displayValue"] = meshes
-
-    b["name"] = to_speckle_name(blender_object)
-    b["@elements"] = curves
-    return b
-
-def curve_to_speckle_geometry(blender_object: Object, data: bpy.types.Curve) -> Tuple[List[Mesh], List[Base]]:
-    assert(blender_object.type == "CURVE")
-
-    blender_object = cast(Object, blender_object.evaluated_get(bpy.context.view_layer.depsgraph))
-
-    matrix = cast(MMatrix, blender_object.matrix_world)
-
-    meshes: List[Mesh] = []
-    curves: List[Base] = []
-
-    #TODO: Could we support this better?
-    if data.bevel_mode == "OBJECT" and data.bevel_object != None:
-        meshes = mesh_to_speckle_meshes(blender_object, blender_object.to_mesh())
-
-    for spline in data.splines:
-        if spline.type == "BEZIER":
-            curves.append(bezier_to_speckle(matrix, spline, to_speckle_name(blender_object)))
-
-        elif spline.type == "NURBS":
-            curves.append(nurbs_to_speckle(matrix, spline, to_speckle_name(blender_object)))
-
-        elif spline.type == "POLY":
-            curves.append(poly_to_speckle(matrix, spline, to_speckle_name(blender_object)))
-
-    return (meshes, curves)
-
-def anything_to_speckle_mesh(blender_object: Object) -> Base:
-
-    mesh = mesh_to_speckle(blender_object, blender_object.to_mesh())
-    blender_object.to_mesh_clear()
-    return mesh
-
-@deprecated
-def ngons_to_speckle_polylines(blender_object: Object, data: bpy.types.Mesh) -> Optional[List[Polyline]]:
-    UNITS = "m" if bpy.context.scene.unit_settings.system == "METRIC" else "ft"
-
-    if blender_object.type != "MESH":
-        return None
-
-    mat = blender_object.matrix_world
-
-    verts = data.vertices
-    polylines = []
-    for i, poly in enumerate(data.polygons):
-        value = []
-        for v in poly.vertices:
-            value.extend(mat @ verts[v].co * UnitsScale) # type: ignore
-
-        domain = Interval(start=0, end=1)
-        poly = Polyline(
-            name="{}_{}".format(blender_object.name, i),
-            closed=True,
-            value=value,
-            length=0,
-            domain=domain,
-            bbox=Box(area=0.0, volume=0.0),
-            area=0,
-            units=UNITS,
-        )
-
-        polylines.append(poly)
-
-    return polylines
-
-
-def material_to_speckle(blender_mat: bpy.types.Material) -> RenderMaterial:
-    speckle_mat = RenderMaterial()
-    speckle_mat.name = blender_mat.name
-
-    if blender_mat.use_nodes:
-        if blender_mat.node_tree.nodes.get("Principled BSDF"):
-            inputs = blender_mat.node_tree.nodes["Principled BSDF"].inputs
-            emission_color = "Emission" if "Emission" in inputs else "Emission Color" # type: ignore 
-            
-            speckle_mat.diffuse = to_argb_int(inputs["Base Color"].default_value) # type: ignore
-            speckle_mat.emissive = to_argb_int(inputs[emission_color].default_value) # type: ignore
-            speckle_mat.roughness = inputs["Roughness"].default_value # type: ignore
-            speckle_mat.metalness = inputs["Metallic"].default_value # type: ignore
-            speckle_mat.opacity = inputs["Alpha"].default_value # type: ignore
-            return speckle_mat
-        elif blender_mat.node_tree.nodes.get("Diffuse BSDF"):
-            inputs = blender_mat.node_tree.nodes["Diffuse BSDF"].inputs
-            speckle_mat.diffuse = to_argb_int(inputs["Color"].default_value) # type: ignore
-            speckle_mat.roughness = inputs["Roughness"].default_value # type: ignore
-            return speckle_mat
-        #TODO: Support more shaders
-
-    # fallback to standard material props
-    speckle_mat.diffuse = to_argb_int(blender_mat.diffuse_color) # type: ignore
-    speckle_mat.metalness = blender_mat.metallic
-    speckle_mat.roughness = blender_mat.roughness
-
-    return speckle_mat
-
-def camera_to_speckle_view(blender_object: Object, data: NCamera) -> Base:
-    if data.type != 'PERSP':
-        raise Exception(f"Cameras of type {data.type} are not currently supported")
-    
-    matrix = cast(MMatrix, blender_object.matrix_world)
-    up = cast(MVector, matrix.col[1].xyz)
-    forwards = cast(MVector, -matrix.col[2].xyz)
-    translation = matrix.translation
-
-    view = Base.of_type("Objects.BuiltElements.View:Objects.BuiltElements.View3D") #HACK: views are not in specklepy yet!
-    view.name = to_speckle_name(blender_object)
-    view.origin = vector_to_speckle_point(translation)
-    view.upDirection = vector_to_speckle(up)
-    view.forwardDirection = vector_to_speckle(forwards)
-    view.target = vector_to_speckle_point(forwards) #TODO: do these need to be scaled?
-    view.units = Units
-    view.isOrthogonal = False
-    return view
-
-def vector_to_speckle_point(xyz: MVector) -> Point:
-    return Point(
-        x = xyz.x * UnitsScale,
-        y = xyz.y * UnitsScale,
-        z = xyz.z * UnitsScale,
-        units = Units,
-        )
-
-def vector_to_speckle(xyz: MVector) -> Vector:
-    return Vector(
-        x = xyz.x * UnitsScale,
-        y = xyz.y * UnitsScale,
-        z = xyz.z * UnitsScale,
-        units = Units,
-        )
-
-def transform_to_speckle(blender_transform: Union[Iterable[Iterable[float]], MMatrix]) -> Transform:
-    iterable_transform = cast(Iterable[Iterable[float]], blender_transform) #NOTE: Matrix are iterable, even if type hinting says they are not
-    value = [y for x in iterable_transform for y in x]
-    # scale the translation
-    for i in (3, 7, 11):
-        value[i] *= UnitsScale
-
-    return Transform(value=value, units=Units)
-
-
-def block_def_to_speckle(blender_definition: bpy.types.Collection) -> BlockDefinition:
-    geometryBuilder = BlenderCommitObjectBuilder()
-    for geo in blender_definition.objects:
-        try:
-            c = convert_to_speckle(geo, UnitsScale, Units, None)
-            geometryBuilder.include_object(c, geo)
-        except ConversionSkippedException as ex:
-            _report(f"Skipped converting '{geo.name_full}' inside collection instance: '{ex}")
-        except Exception as ex:
-            _report(f"Failed to converted '{geo.name_full}' inside collection instance: '{ex}'")
-
-    dummyRoot = Base()
-    geometryBuilder.apply_relationships(geometryBuilder.converted.values(), dummyRoot)
-
-    block_def = BlockDefinition(
-        units=Units,
-        name=to_speckle_name(blender_definition),
-        geometry=dummyRoot["@elements"],
-        basePoint=Point(units=Units),
-    )
-    # blender_props = get_blender_custom_properties(blender_definition)
-    # block_def.applicationId = blender_props.pop("applicationId", None) #TODO: remove?
-    return block_def
-
-
-def block_instance_to_speckle(blender_instance: Object) -> BlockInstance:
-    return BlockInstance(
-        blockDefinition=block_def_to_speckle(
-            blender_instance.instance_collection
-        ),
-        transform=transform_to_speckle(blender_instance.matrix_world),
-        name=to_speckle_name(blender_instance),
-        units=Units,
-    )
-
-
-def empty_to_speckle(blender_object: Object) -> Union[BlockInstance, Base]:
-    # probably an instance collection (block) so let's try it
-
-    if blender_object.instance_collection and blender_object.instance_type == "COLLECTION":
-        # Empty -> Block
-        return block_instance_to_speckle(blender_object)
-    else:
-        # Empty -> Point
-        wrapper = Base()
-        wrapper["@displayValue"] = matrix_to_speckle_point(cast(MMatrix, blender_object.matrix_world))
-        return wrapper
-
-
-def matrix_to_speckle_point(matrix: MMatrix, units_scale: float = 1.0) -> Point:
-    transformed_pos = cast(MVector, matrix @ MVector((0,0,0)) * units_scale)
-    return Point(x = transformed_pos.x,
-                 y = transformed_pos.y, 
-                 z = transformed_pos.z)

bpy_speckle/convert/util.py

@@ -1,493 +0,0 @@
-import math
-from typing import Any, Dict, Optional, Tuple, Union, cast
-from bmesh.types import BMesh
-import bpy, idprop
-
-from specklepy.objects.base import Base
-from specklepy.objects.geometry import Mesh
-from specklepy.objects.other import RenderMaterial
-from bpy_speckle.convert.constants import IGNORED_PROPERTY_KEYS
-from bpy_speckle.functions import _report
-from bpy.types import Material, Object, Collection as BCollection, Node, ShaderNodeVertexColor, NodeInputs
-
-from specklepy.objects.graph_traversal.traversal import TraversalContext
-
-class ConversionSkippedException(Exception):
-    pass
-
-def to_rgba(argb_int: int) -> Tuple[float, float, float, float]:
-    """Converts the int representation of a colour into a percent RGBA tuple"""
-    alpha = ((argb_int >> 24) & 255) / 255
-    red = ((argb_int >> 16) & 255) / 255
-    green = ((argb_int >> 8) & 255) / 255
-    blue = (argb_int & 255) / 255
-
-    return (red, green, blue, alpha)
-
-
-def to_argb_int(rgba_color: list[float]) -> int:
-    """Converts an RGBA array to an ARGB integer"""
-    argb_color = rgba_color[-1:] + rgba_color[:3]
-    int_color = [int(val * 255) for val in argb_color]
-
-    return int.from_bytes(int_color, byteorder="big", signed=True)
-
-def set_custom_property(key: str, value: Any, blender_object: Object) -> None:
-    try:
-        #Expected c types: float, int, string, float[], int[]
-        blender_object[key] = value
-    except (OverflowError, TypeError) as ex:
-        print(f"Skipping setting property ({key}={value}) on {blender_object.name_full}, Reason: {ex}")
-    except Exception as ex:
-        #TODO: Log this as it's unexpected!!!
-        print(f"Skipping setting property ({key}={value}) on {blender_object.name_full}, Reason: {ex}")
-
-def add_custom_properties(speckle_object: Base, blender_object: Object):
-    if blender_object is None:
-        return
-
-    blender_object["_speckle_type"] = type(speckle_object).__name__
-
-    app_id = getattr(speckle_object, "applicationId", None)
-    if app_id:
-        blender_object["applicationId"] = speckle_object.applicationId
-    keys = speckle_object.get_dynamic_member_names() if "Geometry" in speckle_object.speckle_type else (set(speckle_object.get_member_names()) - IGNORED_PROPERTY_KEYS)
-    for key in keys:
-        val = getattr(speckle_object, key, None)
-        if val is None:
-            continue
-
-        if isinstance(val, (int, str, float)):
-            set_custom_property(key, val, blender_object)
-        elif key == "properties" and isinstance(val, Base):
-            val["applicationId"] = None
-            add_custom_properties(val, blender_object)
-        elif isinstance(val, list):
-            items = [item for item in val if not isinstance(item, Base)]
-            if items:
-                set_custom_property(key, items, blender_object)
-        elif isinstance(val,dict):
-            for (k,v) in val.items():
-                if not isinstance(v, Base):
-                    set_custom_property(k, v, blender_object)
-
-
-def render_material_to_native(speckle_mat: RenderMaterial) -> Material:
-    
-    mat_name = speckle_mat.name
-    if not mat_name:
-        mat_name = speckle_mat.applicationId or speckle_mat.id or speckle_mat.get_id()
-
-    blender_mat = bpy.data.materials.get(mat_name)
-    if blender_mat is None:
-        blender_mat = bpy.data.materials.new(mat_name)
-
-        # for now, we're not updating these materials. as per tom's suggestion, we should have a toggle
-        # that enables this as the blender mats will prob be much more complex than whatever is coming in
-        blender_mat.use_nodes = True
-        inputs = blender_mat.node_tree.nodes["Principled BSDF"].inputs
-
-        inputs["Base Color"].default_value = to_rgba(speckle_mat.diffuse) # type: ignore
-        inputs["Roughness"].default_value = speckle_mat.roughness # type: ignore
-        inputs["Metallic"].default_value = speckle_mat.metalness # type: ignore
-        inputs["Alpha"].default_value = speckle_mat.opacity # type: ignore
-
-        # Blender >=4.0 use "Emission Color"
-        emission_color = "Emission" if "Emission" in inputs else "Emission Color" # type: ignore 
-        inputs[emission_color].default_value = to_rgba(speckle_mat.emissive) # type: ignore
-
-    if speckle_mat.opacity < 1.0:
-        blender_mat.blend_method = "BLEND"
-
-    return blender_mat
-
-_vertex_color_material: Optional[Material] = None
-
-def get_vertex_color_material() -> Material:
-    global _vertex_color_material
-    
-    #see https://stackoverflow.com/a/69807985
-    if not _vertex_color_material:
-        _vertex_color_material = bpy.data.materials.new("Vertex Color Material")
-        _vertex_color_material.use_nodes = True
-        nodes = _vertex_color_material.node_tree.nodes
-        principled_bsdf_node = cast(Node, nodes.get("Principled BSDF"))
-    
-        if not "VERTEX_COLOR" in [node.type for node in nodes]:
-            vertex_color_node = cast(ShaderNodeVertexColor, nodes.new(type = "ShaderNodeVertexColor"))
-        else:
-            vertex_color_node = cast(ShaderNodeVertexColor, nodes.get("Vertex Color"))
-        vertex_color_node.layer_name = "Col"
-
-        links = _vertex_color_material.node_tree.links
-        link = links.new(vertex_color_node.outputs[0], principled_bsdf_node.inputs[0])
-
-    return _vertex_color_material
-
-def get_render_material(speckle_object: Base) -> Optional[RenderMaterial]:
-    """Trys to get a RenderMaterial on given speckle_object"""
-
-    speckle_mat = getattr(
-        speckle_object,
-        "renderMaterial",
-        getattr(speckle_object, "@renderMaterial", None),
-    )
-
-    if isinstance(speckle_mat, RenderMaterial):
-        return speckle_mat
-
-    return None
-    
-
-
-def add_vertices(speckle_mesh: Mesh, blender_mesh: BMesh, scale=1.0):
-    sverts = speckle_mesh.vertices
-
-    if sverts and len(sverts) > 0:
-        for i in range(0, len(sverts), 3):
-            blender_mesh.verts.new(
-                (
-                    float(sverts[i]) * scale,
-                    float(sverts[i + 1]) * scale,
-                    float(sverts[i + 2]) * scale,
-                )
-            )
-
-
-
-def add_faces(speckle_mesh: Mesh, blender_mesh: BMesh, indexOffset: int, materialIndex: int = 0, smooth:bool = True):
-    sfaces = speckle_mesh.faces
-    
-    if sfaces and len(sfaces) > 0:
-        i = 0
-        while i < len(sfaces):
-            n = sfaces[i]
-            if n < 3:
-                n += 3  # 0 -> 3, 1 -> 4
-
-            i += 1
-            try:
-                f = blender_mesh.faces.new(
-                    [blender_mesh.verts[x + indexOffset] for x in sfaces[i : i + n]]
-                )
-                f.material_index = materialIndex
-                f.smooth = smooth
-            except Exception as e:
-                _report(f"Failed to create face for mesh {speckle_mesh.id} \n{e}")
-            i += n
-
-
-def add_colors(speckle_mesh: Mesh, blender_mesh: BMesh):
-
-    scolors = speckle_mesh.colors
-
-    if scolors:
-        colors = []
-        if len(scolors) > 0:
-
-            for i in range(len(scolors)):
-                argb = int(scolors[i])
-                (a, r, g, b) = argb_split(argb)
-                colors.append(
-                    (
-                        float(r) / 255.0,
-                        float(g) / 255.0,
-                        float(b) / 255.0,
-                        float(a) / 255.0,
-                    )
-                )
-
-        # Make vertex colors
-        if len(scolors) == len(blender_mesh.verts):
-            color_layer = blender_mesh.loops.layers.color.new("Col")
-
-            for face in blender_mesh.faces:
-                for loop in face.loops:
-                    loop[color_layer] = colors[loop.vert.index]
-
-def argb_split(argb: int) -> Tuple[int, int, int, int]:
-    alpha = (argb >> 24) & 0xFF
-    red = (argb >> 16) & 0xFF
-    green = (argb >> 8) & 0xFF
-    blue = argb & 0xFF
-
-    return (alpha, red, green, blue)
-
-def add_uv_coords(speckle_mesh: Mesh, blender_mesh: BMesh):
-    s_uvs = speckle_mesh.textureCoordinates
-    if not s_uvs:
-        return
-    try:
-        uv = []
-
-        if len(s_uvs) // 2 == len(blender_mesh.verts):
-            uv.extend(
-                (float(s_uvs[i]), float(s_uvs[i + 1]))
-                for i in range(0, len(s_uvs), 2)
-            )
-        else:
-            _report(
-                f"Failed to match UV coordinates to vert data. Blender mesh verts: {len(blender_mesh.verts)}, Speckle UVs: {len(s_uvs) // 2}"
-            )
-            return
-
-        # Make UVs
-        uv_layer = blender_mesh.loops.layers.uv.verify()
-
-        for f in blender_mesh.faces:
-            for l in f.loops:
-                luv = l[uv_layer]
-                luv.uv = uv[l.vert.index]
-    except:
-        _report("Failed to decode texture coordinates.")
-        raise
-
-
-ignored_keys = {
-    "id",
-    "speckle",
-    "speckle_type"
-    "_speckle_type",
-    "_speckle_name",
-    "_speckle_transform",
-    "_RNA_UI",
-    "elements",
-    "transform",
-    "_units",
-    "_chunkable",
-}
-
-def get_blender_custom_properties(obj, max_depth: int = 63):
-    """Recursively grabs custom properties on blender objects. Max depth is determined by the max allowed by Newtonsoft.NET, don't exceed unless you know what you're doing"""
-    if max_depth <= 0:
-        return obj
-
-    if hasattr(obj, "keys"):
-        keys = set(obj.keys()) - ignored_keys
-        return {
-            key: get_blender_custom_properties(obj[key], max_depth - 1)
-            for key in keys
-            if not key.startswith("_")
-        }
-
-    if isinstance(obj, (list, tuple, idprop.types.IDPropertyArray)):
-        return [get_blender_custom_properties(o, max_depth - 1) for o in obj] # type: ignore
-    
-    return obj
-
-"""
-Python implementation of Blender's NURBS curve generation for to Speckle conversion
-from: https://blender.stackexchange.com/a/34276
-based on https://projects.blender.org/blender/blender/src/branch/main/source/blender/blenkernel/intern/curve.cc (check old version)
-"""
-
-def macro_knotsu(nu: bpy.types.Spline) -> int:
-    return nu.order_u + nu.point_count_u + (nu.order_u - 1 if nu.use_cyclic_u else 0)
-
-def macro_segmentsu(nu: bpy.types.Spline) -> int:
-    return nu.point_count_u if nu.use_cyclic_u else nu.point_count_u - 1
-
-def make_knots(nu: bpy.types.Spline) -> list[float]:
-    knots = [0.0] * macro_knotsu(nu)
-    flag = nu.use_endpoint_u + (nu.use_bezier_u << 1)
-    if nu.use_cyclic_u:
-        calc_knots(knots, nu.point_count_u, nu.order_u, 0)
-    else:
-        calc_knots(knots, nu.point_count_u, nu.order_u, flag)
-    return knots
-
-
-def calc_knots(knots: list[float], point_count: int, order: int, flag: int) -> None:
-    pts_order = point_count + order
-    if flag == 1: # CU_NURB_ENDPOINT
-        k = 0.0
-        for a in range(1, pts_order + 1):
-            knots[a - 1] = k
-            if a >= order and a <= point_count:
-                k += 1.0
-    elif flag == 2: # CU_NURB_BEZIER
-        if order == 4:
-            k = 0.34
-            for a in range(pts_order):
-                knots[a] = math.floor(k)
-                k += 1.0 / 3.0
-        elif order == 3:
-            k = 0.6
-            for a in range(pts_order):
-                if a >= order and a <= point_count:
-                    k += 0.5
-                    knots[a] = math.floor(k)
-    else:
-        for a in range(1, len(knots) - 1):
-            knots[a] = a - 1
-
-        knots[-1] = knots[-2]
-
-def basis_nurb(t: float, order: int, point_count: int, knots: list[float], basis: list[float], start: int, end: int) -> Tuple[int, int]:
-    i1 = i2 = 0
-    orderpluspnts = order + point_count
-    opp2 = orderpluspnts - 1
-    
-    # this is for float inaccuracy
-    if t < knots[0]:
-        t = knots[0]
-    elif t > knots[opp2]:
-        t = knots[opp2]
-
-    # this part is order '1'
-    o2 = order + 1
-    for i in range(opp2):
-        if knots[i] != knots[i + 1] and t >= knots[i] and t <= knots[i + 1]:
-            basis[i] = 1.0
-            i1 = i - o2
-            if i1 < 0:
-                i1 = 0
-            i2 = i
-            i += 1
-            while i < opp2:
-                basis[i] = 0.0
-                i += 1
-            break
-
-        else:
-            basis[i] = 0.0
-
-    basis[i] = 0.0 #type: ignore
-
-    # this is order 2, 3, ...
-    for j in range(2, order + 1):
-
-        if i2 + j >= orderpluspnts:
-            i2 = opp2 - j
-
-        for i in range(i1, i2 + 1):
-            if basis[i] != 0.0:
-                d = ((t - knots[i]) * basis[i]) / (knots[i + j - 1] - knots[i])
-            else:
-                d = 0.0
-
-            if basis[i + 1] != 0.0:
-                e = ((knots[i + j] - t) * basis[i + 1]) / (knots[i + j] - knots[i + 1])
-            else:
-                e = 0.0
-
-            basis[i] = d + e
-
-    start = 1000
-    end = 0
-
-    for i in range(i1, i2 + 1):
-        if basis[i] > 0.0:
-            end = i
-            if start == 1000:
-                start = i
-
-    return start, end
-
-def nurb_make_curve(nu: bpy.types.Spline, resolu: int, stride: int = 3) -> list[float]:
-    """"BKE_nurb_makeCurve"""
-    EPS = 1e-6
-    coord_index = istart = iend = 0
-
-    coord_array = [0.0] * (3 * nu.resolution_u * macro_segmentsu(nu))
-    sum_array = [0] * nu.point_count_u
-    basisu = [0.0] * macro_knotsu(nu)
-    knots = make_knots(nu)
-
-    resolu = resolu * macro_segmentsu(nu)
-    ustart = knots[nu.order_u - 1]
-    uend   = knots[nu.point_count_u + nu.order_u - 1] if nu.use_cyclic_u else \
-             knots[nu.point_count_u]
-    ustep  = (uend - ustart) / (resolu - (0 if nu.use_cyclic_u else 1))
-    cycl = nu.order_u - 1 if nu.use_cyclic_u else 0
-
-    u = ustart
-    while resolu:
-        resolu -= 1
-        istart, iend = basis_nurb(u, nu.order_u, nu.point_count_u + cycl, knots, basisu, istart, iend)
-
-        #/* calc sum */
-        sumdiv = 0.0
-        sum_index = 0
-        pt_index = istart - 1
-        for i in range(istart, iend + 1):
-            if i >= nu.point_count_u:
-                pt_index = i - nu.point_count_u
-            else:
-                pt_index += 1
-
-            sum_array[sum_index] = basisu[i] * nu.points[pt_index].co[3] #type: ignore
-            sumdiv += sum_array[sum_index]
-            sum_index += 1
-
-        if (sumdiv != 0.0) and (sumdiv < 1.0 - EPS or sumdiv > 1.0 + EPS):
-            sum_index = 0
-            for i in range(istart, iend + 1):
-                sum_array[sum_index] /= sumdiv #type: ignore
-                sum_index += 1
-
-        coord_array[coord_index: coord_index + 3] = (0.0, 0.0, 0.0)
-
-        sum_index = 0
-        pt_index = istart - 1
-        for i in range(istart, iend + 1):
-            if i >= nu.point_count_u:
-                pt_index = i - nu.point_count_u
-            else:
-                pt_index += 1
-
-            if sum_array[sum_index] != 0.0:
-                for j in range(3):
-                    coord_array[coord_index + j] += sum_array[sum_index] * nu.points[pt_index].co[j]
-            sum_index += 1
-
-        coord_index += stride
-        u += ustep
-
-    return coord_array
-
-def link_object_to_collection_nested(obj: Object, col: BCollection):
-    if obj.name not in col.objects: #type: ignore
-        col.objects.link(obj)
-
-    for child in obj.children:
-        link_object_to_collection_nested(child, col)
-
-def add_to_hierarchy(converted: Union[Object, BCollection], traversalContext : 'TraversalContext', converted_objects: Dict[str, Union[Object, BCollection]], preserve_transform: bool) -> None:
-    nextParent = traversalContext.parent
-
-    # Traverse up the tree to find a direct parent object, and a containing collection
-    parent_collection: Optional[BCollection] = None
-    parent_object: Optional[Object] = None
-
-    while nextParent:
-        if nextParent.current.id in converted_objects:
-            c = converted_objects[nextParent.current.id]
-
-            if isinstance(c, BCollection):
-                parent_collection = c
-                break
-            else: #isinstance(c, Object):
-                parent_object = parent_object or c
-
-        nextParent = nextParent.parent
-
-    # If no containing collection is found, fall back to the scene collection
-    if not parent_collection:
-        parent_collection = bpy.context.scene.collection
-
-    if isinstance(converted, Object):
-        if parent_object:
-            set_parent(converted, parent_object, preserve_transform)
-        link_object_to_collection_nested(converted, parent_collection)
-    elif converted.name not in parent_collection.children.keys():
-        parent_collection.children.link(converted)
-
-
-def set_parent(child: Object, parent: Object, preserve_transform: bool = False) -> None:
-    if preserve_transform :
-        previous = child.matrix_world.copy() # type: ignore
-        child.parent = parent
-        child.matrix_world = previous
-    else:
-        child.parent = parent

bpy_speckle/converter/__init__.py

@@ -0,0 +1,2 @@
+from ..converter.to_native import *
+from ..converter.utils import *

bpy_speckle/converter/to_native.py

@@ -0,0 +1,604 @@
+from typing import Any, Iterable, List, Optional, Tuple, Dict
+from specklepy.objects import Base
+from specklepy.objects.geometry import Line, Polyline, Mesh
+from specklepy.objects.models.units import (
+    get_units_from_string,
+    get_scale_factor_to_meters,
+)
+import bpy
+from bpy.types import Object
+from ..converter.utils import create_material_from_proxy
+
+# Display value property aliases to check for
+DISPLAY_VALUE_PROPERTY_ALIASES = [
+    "displayValue",
+    "displayvalue",
+    "@displayValue",
+    "display_value",
+]
+
+# Element property aliases for collections of objects
+ELEMENTS_PROPERTY_ALIASES = [
+    "elements",
+    "@elements",
+]
+
+
+def get_scale_factor(speckle_object: Base, fallback: float = 1.0) -> float:
+    """
+    Determines the correct scale factor based on object units
+    """
+    scale = fallback
+
+    if hasattr(speckle_object, "units") and speckle_object.units:
+        # Get scale factor to convert from object units to meters
+        unit_scale = get_scale_factor_to_meters(
+            get_units_from_string(speckle_object.units)
+        )
+
+        # Adjust for Blender's unit scale setting
+        blender_unit_scale = bpy.context.scene.unit_settings.scale_length
+
+        # Calculate final scale factor
+        scale = unit_scale / blender_unit_scale
+
+    return scale
+
+
+def generate_unique_name(speckle_object: Base) -> Tuple[str, str]:
+    """
+    generates unique name for converted blender objects and data-blocks
+    """
+    # Check if speckle object is a data object
+    # Since every data object has name, use it in naming
+    # If not extract base name from speckle type itself
+    if (
+        "DataObject" in speckle_object.speckle_type
+        and hasattr(speckle_object, "name")
+        and speckle_object.name
+    ):
+        base_name = speckle_object.name
+    else:
+        parts = speckle_object.speckle_type.split(".")
+        base_name = parts[-1]
+
+    # Get the speckle id
+    speckle_id = ""
+    if hasattr(speckle_object, "id") and speckle_object.id:
+        speckle_id = speckle_object.id
+    else:
+        raise KeyError("No id has been found!")  # is that even possible?
+
+    # Define object name - should be simple
+    object_name = base_name
+
+    # Define data-block name - should include ID
+    datablock_name = f"{base_name}.{speckle_id}"
+
+    return object_name, datablock_name
+
+
+def convert_to_native(
+    speckle_object: Base,
+    material_mapping: Optional[Dict[str, bpy.types.Material]] = None,
+) -> Optional[Object]:
+    """
+    converts a speckle object to blender object with material support
+    """
+    # Determine scale factor based on object units
+    scale = get_scale_factor(speckle_object)
+
+    # Generate names
+    object_name, data_block_name = generate_unique_name(speckle_object)
+
+    converted_object = None
+
+    # Initialize material mapping if not provided
+    if material_mapping is None:
+        material_mapping = {}
+
+    # Try direct conversion based on object type
+    if isinstance(speckle_object, Line):
+        converted_object = line_to_native(
+            speckle_object, object_name, data_block_name, scale
+        )
+    elif isinstance(speckle_object, Polyline):
+        converted_object = polyline_to_native(
+            speckle_object, object_name, data_block_name, scale
+        )
+    elif isinstance(speckle_object, Mesh):
+        converted_object = mesh_to_native(
+            speckle_object, object_name, data_block_name, scale, material_mapping
+        )
+    else:
+        # Fallback to display value if direct conversion not supported
+        mesh, children = display_value_to_native(
+            speckle_object, object_name, data_block_name, scale, material_mapping
+        )
+        if mesh:
+            # Create a mesh object with the object_name (simple name) and mesh data
+            mesh_obj = bpy.data.objects.new(object_name, mesh)
+            converted_object = mesh_obj
+
+            # Parent any child objects to this mesh object
+            for child in children:
+                child.parent = mesh_obj
+        elif children:
+            # If we only have non-mesh objects, return the first one as the main object
+            converted_object = children[0]
+
+            # If there are multiple objects, parent remaining ones to the first
+            for child in children[1:]:
+                child.parent = converted_object
+
+    if converted_object:
+        # Store Speckle ID in custom property
+        converted_object["speckle_id"] = speckle_object.id
+
+    return converted_object
+
+
+def display_value_to_native(
+    speckle_object: Base,
+    object_name: str,
+    data_block_name: str,
+    scale: float,
+    material_mapping: Optional[Dict[str, bpy.types.Material]] = None,
+) -> Tuple[Optional[bpy.types.Mesh], List[Object]]:
+    """
+    fallback conversion mechanism using displayValue if present
+    """
+    return _members_to_native(
+        speckle_object,
+        object_name,
+        data_block_name,
+        scale,
+        DISPLAY_VALUE_PROPERTY_ALIASES,
+        True,
+        material_mapping,
+    )
+
+
+def elements_to_native(
+    speckle_object: Base,
+    object_name: str,
+    data_block_name: str,
+    scale: float,
+    material_mapping: Optional[Dict[str, bpy.types.Material]] = None,
+) -> List[Object]:
+    """
+    convert elements collection of a speckle object
+    """
+    (_, elements) = _members_to_native(
+        speckle_object,
+        object_name,
+        data_block_name,
+        scale,
+        ELEMENTS_PROPERTY_ALIASES,
+        False,
+        material_mapping,
+    )
+    return elements
+
+
+def _members_to_native(
+    speckle_object: Base,
+    object_name: str,
+    data_block_name: str,
+    scale: float,
+    members: Iterable[str],
+    combineMeshes: bool,
+    material_mapping: Optional[Dict[str, bpy.types.Material]] = None,
+) -> Tuple[Optional[bpy.types.Mesh], List[Object]]:
+    """
+    converts a given speckle_object by converting specified members
+    """
+    meshes: List[Mesh] = []
+    others: List[Base] = []
+
+    for alias in members:
+        display = getattr(speckle_object, alias, None)
+
+        count = 0
+        MAX_DEPTH = 255  # some large value, to prevent infinite recursion
+
+        def separate(value: Any) -> bool:
+            nonlocal meshes, others, count, MAX_DEPTH
+
+            if combineMeshes and isinstance(value, Mesh):
+                meshes.append(value)
+            elif isinstance(value, Base):
+                others.append(value)
+            elif isinstance(value, list):
+                count += 1
+                if count > MAX_DEPTH:
+                    return True
+                for x in value:
+                    separate(x)
+
+            return False
+
+        did_halt = separate(display)
+
+        if did_halt:
+            print(
+                f"Traversal of {speckle_object.speckle_type} {speckle_object.id} halted after traversal depth exceeds MAX_DEPTH={MAX_DEPTH}. Are there circular references in object structure?"
+            )
+
+    children: List[Object] = []
+    mesh = None
+
+    if meshes:
+        # Use data_block_name (the name with ID) for the mesh datablock
+        mesh = meshes_to_native(
+            speckle_object, meshes, data_block_name, scale, material_mapping
+        )
+
+    for item in others:
+        try:
+            blender_object = convert_to_native(item, material_mapping)
+            if blender_object:
+                children.append(blender_object)
+        except Exception as ex:
+            print(f"Failed to convert display value {item}: {ex}")
+
+    return (mesh, children)
+
+
+def line_to_native(
+    speckle_line: Line, object_name: str, data_block_name: str, scale: float = 1.0
+) -> bpy.types.Object:
+    """
+    converts a speckle line to a blender curve
+    """
+    # Check if the line has valid start and end points
+    if not speckle_line.start or not speckle_line.end:
+        raise ValueError("Line is missing start or end point")
+
+    # Create curve data with data_block_name (the name with ID)
+    curve = bpy.data.curves.new(data_block_name, type="CURVE")
+    curve.dimensions = "3D"
+
+    # Create a new spline in the curve
+    spline = curve.splines.new("POLY")
+    spline.points.add(1)
+
+    # Set the coordinates with scale applied
+    spline.points[0].co = (
+        float(speckle_line.start.x) * scale,
+        float(speckle_line.start.y) * scale,
+        float(speckle_line.start.z) * scale,
+        1.0,
+    )
+
+    spline.points[1].co = (
+        float(speckle_line.end.x) * scale,
+        float(speckle_line.end.y) * scale,
+        float(speckle_line.end.z) * scale,
+        1.0,
+    )
+
+    # Create object with object_name (the simple name)
+    curve_obj = bpy.data.objects.new(object_name, curve)
+
+    return curve_obj
+
+
+def polyline_to_native(
+    speckle_polyline: Polyline,
+    object_name: str,
+    data_block_name: str,
+    scale: float = 1.0,
+) -> Object:
+    """
+    converts a speckle polyline to blender curve
+    """
+    # Check if polyline has valid points
+    if not speckle_polyline.value or len(speckle_polyline.value) < 6:
+        raise ValueError("Polyline must have at least two points")
+
+    # Create curve data with data_block_name (the name with ID)
+    curve = bpy.data.curves.new(data_block_name, type="CURVE")
+    curve.dimensions = "3D"
+
+    # Create a new spline in the curve
+    spline = curve.splines.new("POLY")
+
+    # Get the number of points in the polyline
+    num_points = len(speckle_polyline.value) // 3  # divide by 3 to get point count
+
+    # Add the required number of points to the spline
+    if num_points > 1:
+        spline.points.add(num_points - 1)
+
+    # Set the coordinates for each point with scale applied
+    for i in range(num_points):
+        # Note: Blender curve points are 4D (x, y, z, w) where w is weight
+        spline.points[i].co = (
+            float(speckle_polyline.value[i * 3]) * scale,
+            float(speckle_polyline.value[i * 3 + 1]) * scale,
+            float(speckle_polyline.value[i * 3 + 2]) * scale,
+            1.0,
+        )
+
+    # Set cyclic property if the polyline is closed
+    if hasattr(speckle_polyline, "closed") and speckle_polyline.closed:
+        spline.use_cyclic_u = True
+
+    # Create object with object_name (the simple name)
+    curve_obj = bpy.data.objects.new(object_name, curve)
+
+    return curve_obj
+
+
+def mesh_to_native(
+    speckle_mesh: Mesh,
+    object_name: str,
+    data_block_name: str,
+    scale: float = 1.0,
+    material_mapping: Optional[Dict[str, bpy.types.Material]] = None,
+) -> Object:
+    """
+    converts a speckle mesh to a blender mesh with material support
+    """
+    # Create mesh data with data_block_name (the name with ID)
+    mesh = mesh_to_native_mesh(speckle_mesh, data_block_name, scale)
+
+    # Create object with object_name (the simple name)
+    mesh_obj = bpy.data.objects.new(object_name, mesh)
+
+    # Add vertex colors if present
+    if len(speckle_mesh.colors) > 0:
+        add_vertex_colors(mesh, speckle_mesh.colors)
+
+    # Add texture coordinates if present
+    if len(speckle_mesh.textureCoordinates) > 0:
+        add_texture_coordinates(mesh, speckle_mesh.textureCoordinates)
+
+    # Apply material if available for this mesh
+    if material_mapping and hasattr(speckle_mesh, "applicationId"):
+        app_id = speckle_mesh.applicationId
+        if app_id in material_mapping:
+            material = material_mapping[app_id]
+            mesh.materials.append(material)
+
+    return mesh_obj
+
+
+def mesh_to_native_mesh(
+    speckle_mesh: Mesh, name: str, scale: float = 1.0
+) -> bpy.types.Mesh:
+    """
+    converts a single Speckle mesh to a Blender mesh object
+    """
+    # Check if the mesh has valid vertices and faces
+    if not speckle_mesh.vertices or not speckle_mesh.faces:
+        raise ValueError("Mesh has no vertices or faces")
+
+    # Create a new mesh object with the provided name (with ID)
+    blender_mesh = bpy.data.meshes.new(name)
+
+    # Prepare vertices and faces with scale applied
+    vertices = []
+    for i in range(0, len(speckle_mesh.vertices), 3):
+        vertices.append(
+            (
+                float(speckle_mesh.vertices[i]) * scale,
+                float(speckle_mesh.vertices[i + 1]) * scale,
+                float(speckle_mesh.vertices[i + 2]) * scale,
+            )
+        )
+
+    # Extract faces from the Speckle mesh format
+    faces = []
+    i = 0
+    while i < len(speckle_mesh.faces):
+        vertex_count = speckle_mesh.faces[i]
+        face = []
+        for j in range(1, vertex_count + 1):
+            vertex_index = speckle_mesh.faces[i + j]
+            face.append(vertex_index)
+        faces.append(face)
+        i += vertex_count + 1
+
+    # Create the mesh from vertices and faces
+    blender_mesh.from_pydata(vertices, [], faces)
+    blender_mesh.update()
+
+    return blender_mesh
+
+
+def meshes_to_native(
+    speckle_object: Base,
+    meshes: List[Mesh],
+    name: str,
+    scale: float,
+    material_mapping: Optional[Dict[str, bpy.types.Material]] = None,
+) -> bpy.types.Mesh:
+    """
+    combines multiple Speckle meshes into a single Blender mesh with material support
+    """
+    # If there's only one mesh, use the simpler conversion function
+    if len(meshes) == 1:
+        blender_mesh = mesh_to_native_mesh(meshes[0], name, scale)
+
+        # Apply material if available for this mesh
+        if material_mapping and hasattr(meshes[0], "applicationId"):
+            app_id = meshes[0].applicationId
+            if app_id in material_mapping:
+                material = material_mapping[app_id]
+                blender_mesh.materials.append(material)
+
+        return blender_mesh
+
+    # Create a new mesh object with the provided name
+    blender_mesh = bpy.data.meshes.new(name)
+
+    # Track face ranges for each mesh for material assignment
+    mesh_face_ranges = []  # List of (start_face, end_face, mesh_index)
+    current_face = 0
+
+    # Track materials needed
+    mesh_materials = {}  # Maps mesh index to material
+
+    # Process all meshes and combine them
+    all_vertices = []
+    all_faces = []
+    vertex_offset = 0
+
+    # First pass: collect vertices, faces, and track face ranges
+    for mesh_idx, mesh in enumerate(meshes):
+        start_face = current_face
+
+        # Check if this mesh has a material
+        if material_mapping and hasattr(mesh, "applicationId"):
+            app_id = mesh.applicationId
+            if app_id in material_mapping:
+                mesh_materials[mesh_idx] = material_mapping[app_id]
+
+        # Add vertices with scale applied
+        for i in range(0, len(mesh.vertices), 3):
+            all_vertices.append(
+                (
+                    float(mesh.vertices[i]) * scale,
+                    float(mesh.vertices[i + 1]) * scale,
+                    float(mesh.vertices[i + 2]) * scale,
+                )
+            )
+
+        # Add faces
+        i = 0
+        face_count = 0
+        while i < len(mesh.faces):
+            vertex_count = mesh.faces[i]
+            face = []
+            for j in range(1, vertex_count + 1):
+                vertex_index = mesh.faces[i + j]
+                face.append(vertex_index + vertex_offset)
+            all_faces.append(face)
+            i += vertex_count + 1
+            face_count += 1
+            current_face += 1
+
+        # Update vertex offset for the next mesh
+        vertex_offset += len(mesh.vertices) // 3
+
+        # Store face range if this mesh has faces
+        if face_count > 0:
+            mesh_face_ranges.append((start_face, current_face - 1, mesh_idx))
+
+    # Create the combined mesh
+    blender_mesh.from_pydata(all_vertices, [], all_faces)
+    blender_mesh.update()
+
+    # If we have materials, add them to the mesh
+    if mesh_materials:
+        # First add all materials to the mesh
+        materials_added = set()
+        material_indices = {}  # Maps material name to index in the mesh
+
+        for mesh_idx, material in mesh_materials.items():
+            if material.name not in materials_added:
+                blender_mesh.materials.append(material)
+                material_indices[material.name] = len(blender_mesh.materials) - 1
+                materials_added.add(material.name)
+
+        # Now assign materials to faces based on which mesh they came from
+        for start_face, end_face, mesh_idx in mesh_face_ranges:
+            if mesh_idx in mesh_materials:
+                material = mesh_materials[mesh_idx]
+                material_index = material_indices[material.name]
+
+                # Assign this material to all faces in this range
+                for face_idx in range(start_face, end_face + 1):
+                    if face_idx < len(blender_mesh.polygons):
+                        blender_mesh.polygons[face_idx].material_index = material_index
+
+    return blender_mesh
+
+
+def add_vertex_colors(blender_mesh: bpy.types.Mesh, colors: List[int]) -> None:
+    """
+    add vertex colors to a Blender mesh
+    """
+    if not blender_mesh.vertices or len(colors) < len(blender_mesh.vertices) * 4:
+        return
+
+    # Create a new vertex color layer
+    if not blender_mesh.vertex_colors:
+        blender_mesh.vertex_colors.new()
+
+    color_layer = blender_mesh.vertex_colors.active
+
+    # Set vertex colors for each loop
+    for poly in blender_mesh.polygons:
+        for loop_idx in poly.loop_indices:
+            vertex_idx = blender_mesh.loops[loop_idx].vertex_index
+            color_idx = vertex_idx * 4
+
+            # RGBA values normalized to 0.0-1.0 range
+            r = colors[color_idx] / 255.0
+            g = colors[color_idx + 1] / 255.0
+            b = colors[color_idx + 2] / 255.0
+            a = colors[color_idx + 3] / 255.0
+
+            color_layer.data[loop_idx].color = (r, g, b, a)
+
+
+def add_texture_coordinates(
+    blender_mesh: bpy.types.Mesh, tex_coords: List[float]
+) -> None:
+    """
+    add texture coordinates to a Blender mesh
+    """
+    if not blender_mesh.vertices or len(tex_coords) < len(blender_mesh.vertices) * 2:
+        return
+
+    # Create a new UV layer
+    if not blender_mesh.uv_layers:
+        blender_mesh.uv_layers.new()
+
+    uv_layer = blender_mesh.uv_layers.active
+
+    # Set UV coordinates for each loop
+    for poly in blender_mesh.polygons:
+        for loop_idx in poly.loop_indices:
+            vertex_idx = blender_mesh.loops[loop_idx].vertex_index
+            uv_idx = vertex_idx * 2
+
+            u = tex_coords[uv_idx]
+            v = tex_coords[uv_idx + 1]
+
+            uv_layer.data[loop_idx].uv = (u, v)
+
+
+def render_material_proxy_to_native(
+    speckle_object: Base,
+) -> Dict[str, bpy.types.Material]:
+    """
+    converts RenderMaterialProxies to Blender materials
+    """
+    assigned_objects = {}
+
+    # check if object has renderMaterialProxies
+    if not hasattr(speckle_object, "renderMaterialProxies"):
+        print("No render material proxies found!")
+        return assigned_objects
+
+    # process each render material proxy
+    for proxy in speckle_object.renderMaterialProxies:
+        if not hasattr(proxy, "value") or not hasattr(proxy, "objects"):
+            print("Render material proxy has no value or no object has assigned!")
+            continue
+        render_material = proxy.value
+        material_name = getattr(render_material, "name")
+
+        # create blender material
+        blender_material = create_material_from_proxy(render_material, material_name)
+
+        # map application ids to this material
+        for applicationId in proxy.objects:
+            assigned_objects[applicationId] = blender_material
+
+    # return the mapping
+    return assigned_objects

bpy_speckle/converter/utils.py

@@ -0,0 +1,90 @@
+from typing import Tuple, List
+import bpy
+
+
+def to_rgba(argb_int: int) -> Tuple[float, float, float, float]:
+    """
+    converts the int representation of a colour into a RGBA tuple
+    """
+    alpha = ((argb_int >> 24) & 255) / 255
+    red = ((argb_int >> 16) & 255) / 255
+    green = ((argb_int >> 8) & 255) / 255
+    blue = (argb_int & 255) / 255
+    return (red, green, blue, alpha)
+
+
+def to_argb_int(rgba_color: List[float]) -> int:
+    """
+    converts an RGBA array to an ARGB integer
+    """
+    argb_color = rgba_color[-1:] + rgba_color[:3]
+    int_color = [int(val * 255) for val in argb_color]
+    return int.from_bytes(int_color, byteorder="big", signed=True)
+
+
+def create_material_from_proxy(
+    render_material, material_name: str
+) -> bpy.types.Material:
+    """
+    creates a Blender material from a Speckle RenderMaterial
+    """
+    # check if material already exists with this name
+    if material_name in bpy.data.materials:
+        return bpy.data.materials[material_name]
+
+    # create new material
+    material = bpy.data.materials.new(name=material_name)
+    material.use_nodes = True
+    node_tree = material.node_tree
+    nodes = node_tree.nodes
+
+    # clear all nodes
+    for node in nodes:
+        nodes.remove(node)
+
+    # create basic Principled BSDF and output nodes
+    bsdf = nodes.new(type="ShaderNodeBsdfPrincipled")
+    output = nodes.new(type="ShaderNodeOutputMaterial")
+
+    # link shader to output
+    node_tree.links.new(bsdf.outputs["BSDF"], output.inputs["Surface"])
+
+    # set material properties
+    if hasattr(render_material, "diffuse"):
+        diffuse_rgba = to_rgba(render_material.diffuse)
+        bsdf.inputs["Base Color"].default_value = (
+            diffuse_rgba[0],
+            diffuse_rgba[1],
+            diffuse_rgba[2],
+            1.0,
+        )
+
+    if hasattr(render_material, "opacity"):
+        opacity = float(render_material.opacity)
+        if opacity < 1.0:
+            material.blend_method = "BLEND"
+            bsdf.inputs["Alpha"].default_value = opacity
+
+    if hasattr(render_material, "metalness"):
+        metalness = float(render_material.metalness)
+        bsdf.inputs["Metallic"].default_value = metalness
+
+    if hasattr(render_material, "roughness"):
+        roughness = float(render_material.roughness)
+        bsdf.inputs["Roughness"].default_value = roughness
+
+    if (
+        hasattr(render_material, "emissive") and render_material.emissive != -16777216
+    ):  # default black
+        emissive_rgba = to_rgba(render_material.emissive)
+        # only add emission if it's not black (default)
+        if any(val > 0.01 for val in emissive_rgba[:3]):
+            bsdf.inputs["Emission Color"].default_value = (
+                emissive_rgba[0],
+                emissive_rgba[1],
+                emissive_rgba[2],
+                1.0,
+            )
+            bsdf.inputs["Emission Strength"].default_value = 1.0
+
+    return material

bpy_speckle/functions.py

@@ -1,45 +0,0 @@
-from typing import Callable
-from specklepy.objects.base import Base
-from bpy_speckle.convert.constants import ELEMENTS_PROPERTY_ALIASES
-
-from specklepy.objects.graph_traversal.traversal import GraphTraversal, TraversalRule
-from specklepy.objects.units import get_scale_factor_to_meters, get_units_from_string
-
-
-def _report(msg: object) -> None:
-    """
-    Function for printing messages to the console
-    """
-    print("SpeckleBlender: {}".format(msg))
-
-
-def get_scale_length(units: str) -> float:
-    """Returns a scalar to convert distance values from one unit system to meters"""
-    return get_scale_factor_to_meters(get_units_from_string(units))
-
-
-def get_default_traversal_func(can_convert_to_native: Callable[[Base], bool]) -> GraphTraversal:
-    """
-    Traversal func for traversing a speckle commit object
-    """
-    
-    ignore_rule = TraversalRule(
-    [
-        lambda o: "Objects.Structural.Results" in o.speckle_type, #Sadly, this one is necessary to avoid double conversion...
-        lambda o: "Objects.BuiltElements.Revit.Parameter" in o.speckle_type, #This one is just for traversal performance of revit commits
-    ], 
-    lambda _: [],
-    )
-
-    convertible_rule = TraversalRule(
-    [can_convert_to_native],
-    lambda _: ELEMENTS_PROPERTY_ALIASES,
-    )
-
-
-    default_rule = TraversalRule(
-    [lambda _: True],
-    lambda o: o.get_member_names(), #TODO: avoid deprecated members
-    )
-
-    return GraphTraversal([ignore_rule, convertible_rule, default_rule])

bpy_speckle/installer.py

@@ -135,6 +135,24 @@ def ensure_pip() -> None:
         raise Exception(f"Failed to install pip, got {completed_process.returncode} return code")
 
 
+def is_uv_available() -> bool:
+    try:
+        import_module("uv")  # noqa F401
+        return True
+    except ImportError:
+        return False
+
+
+def ensure_uv() -> None:
+    print("Installing uv... ")
+    from subprocess import run
+    completed_process = run([PYTHON_PATH, "-m", "pip", "install", "uv"])
+    if completed_process.returncode == 0:
+        print("Successfully installed uv")
+    else:
+        raise Exception(f"Failed to install uv, got {completed_process.returncode} return code")
+
+
 def get_requirements_path() -> Path:
     # we assume that a requirements.txt exists next to the __init__.py file
     path = Path(Path(__file__).parent, "requirements.txt")
@@ -166,14 +184,11 @@ def install_requirements(host_application: str) -> None:
         [
             PYTHON_PATH,
             "-m",
+            "uv",
             "pip",
-            "-q",
-            "--disable-pip-version-check",
             "install",
-            "--prefer-binary",
-            "--ignore-installed",
-            "--no-compile",
-            "-t",
+            "--system",
+            "--target",
             str(path),
             "-r",
             str(requirements_path),
@@ -183,7 +198,7 @@ def install_requirements(host_application: str) -> None:
     )
 
     if completed_process.returncode != 0:
-        m = f"Failed to install dependencies through pip, got {completed_process.returncode} return code"
+        m = f"Failed to install dependencies through uv, got {completed_process.returncode} return code"
         print(m)
         raise Exception(m)
     
@@ -196,6 +211,9 @@ def install_requirements(host_application: str) -> None:
 def install_dependencies(host_application: str) -> None:
     if not is_pip_available():
         ensure_pip()
+    
+    if not is_uv_available():
+        ensure_uv()
 
     install_requirements(host_application)
 

bpy_speckle/operators/__init__.py

@@ -1,64 +0,0 @@
-from .users import LoadUsers, LoadUserStreams, ResetUsers
-from .object import (
-    UpdateObject,
-    ResetObject,
-    DeleteObject,
-    UploadNgonsAsPolylines,
-    SelectIfSameCustomProperty,
-    SelectIfHasCustomProperty,
-)
-from .streams import (
-    ReceiveStreamObjects,
-    SendStreamObjects,
-    ViewStreamDataApi,
-    DeleteStream,
-    SelectOrphanObjects,
-)
-from .streams import (
-    AddStreamFromURL,
-    CreateStream,
-    CopyStreamId,
-    CopyCommitId,
-    CopyBranchName,
-    CopyModelId,
-)
-from .commit import DeleteCommit
-from .misc import OpenSpeckleGuide, OpenSpeckleTutorials, OpenSpeckleForum
-
-operator_classes = [
-    LoadUsers,
-    ResetUsers,
-    ReceiveStreamObjects,
-    SendStreamObjects,
-    LoadUserStreams,
-    CopyStreamId,
-    CopyCommitId,
-    CopyBranchName,
-    CopyModelId,
-]
-
-operator_classes.extend([DeleteCommit])
-
-operator_classes.extend(
-    [
-        UpdateObject,
-        ResetObject,
-        DeleteObject,
-        UploadNgonsAsPolylines,
-        SelectIfSameCustomProperty,
-        SelectIfHasCustomProperty,
-    ]
-)
-
-operator_classes.extend(
-    [
-        ViewStreamDataApi,
-        DeleteStream,
-        SelectOrphanObjects,
-        AddStreamFromURL,
-        CreateStream,
-        OpenSpeckleGuide,
-        OpenSpeckleTutorials,
-        OpenSpeckleForum,
-    ]
-)

bpy_speckle/operators/commit.py

@@ -1,72 +0,0 @@
-"""
-Commit operators
-"""
-import bpy
-from bpy.props import BoolProperty
-from bpy_speckle.clients import speckle_clients
-from bpy_speckle.functions import _report
-from bpy_speckle.properties.scene import get_speckle
-from specklepy.logging import metrics
-
-
-class DeleteCommit(bpy.types.Operator):
-    """
-    Permanently deletes the selected version from the selected model.
-    To execute from code, call: `bpy.ops.speckle.delete_commit(are_you_sure=True)`
-    """
-
-    bl_idname = "speckle.delete_commit"
-    bl_label = "Delete Version"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Permanently Deletes the selected version from the selected model"
-
-    are_you_sure: BoolProperty(
-        name="Confirm",
-        default=False,
-    ) # type: ignore
-
-    def draw(self, context):
-        layout = self.layout
-        col = layout.column()
-        col.prop(self, "are_you_sure")
-
-    def invoke(self, context, event):
-        speckle = get_speckle(context)
-        wm = context.window_manager
-        if len(speckle.users) > 0:
-            return wm.invoke_props_dialog(self)
-
-        return {"CANCELLED"}
-
-    def execute(self, context):
-        if not self.are_you_sure:
-            _report("Cancelled by user")
-            return {"CANCELLED"}
-        self.are_you_sure = False
-
-        self.delete_commit(context)
-        return {"FINISHED"}
-
-    @staticmethod
-    def delete_commit(context: bpy.types.Context) -> None: 
-        speckle = get_speckle(context)
-
-        (_, stream, branch, commit) = speckle.validate_commit_selection()
-
-        client = speckle_clients[int(speckle.active_user)]
-
-        deleted = client.commit.delete(stream_id=stream.id, commit_id=commit.id)
-
-        metrics.track(
-            "Connector Action",
-            client.account, 
-            custom_props={
-                "name": "delete_commit"
-            },
-        )
-        
-        if not deleted:
-            raise Exception("Delete operation failed")
-
-        print(f"Version {commit.id} ({commit.message}) of model {branch.id} ({branch.name}) has been deleted from project {stream.id} ({stream.name})")
-

bpy_speckle/operators/misc.py

@@ -1,65 +0,0 @@
-import bpy
-import webbrowser
-from specklepy.logging import metrics 
-
-
-
-
-class OpenSpeckleGuide(bpy.types.Operator):
-    _guide_url = "https://speckle.guide/user/blender.html"
-
-    bl_idname = "speckle.open_speckle_guide"
-    bl_label = "Speckle Docs"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = f"Browse the documentation on the Speckle Guide ({_guide_url})"
-    
-    def execute(self, context):
-        webbrowser.open(self._guide_url)
-        metrics.track(
-            "Connector Action",
-            None, 
-            custom_props={
-                "name": "OpenSpeckleGuide"
-            },
-        )
-        return {"FINISHED"}
-
-
-class OpenSpeckleTutorials(bpy.types.Operator):
-    _tutorials_url = "https://speckle.systems/tutorials/"
-
-    bl_idname = "speckle.open_speckle_tutorials"
-    bl_label = "Tutorials Portal"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = f"Visit our tutorials portal for learning resources ({_tutorials_url})"
-
-    def execute(self, context):
-        webbrowser.open(self._tutorials_url)
-        metrics.track(
-            "Connector Action",
-            None, 
-            custom_props={
-                "name": "OpenSpeckleTutorials"
-            },
-        )
-        return {"FINISHED"}
-
-
-class OpenSpeckleForum(bpy.types.Operator):
-    _forum_url = "https://speckle.community/"
-
-    bl_idname = "speckle.open_speckle_forum"
-    bl_label = "Community Forum"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = f"Ask questions and join the discussion on our community forum ({_forum_url})"
-
-    def execute(self, context):
-        webbrowser.open(self._forum_url)
-        metrics.track(
-            "Connector Action",
-            None, 
-            custom_props={
-                "name": "OpenSpeckleForum"
-            },
-        )
-        return {"FINISHED"}

bpy_speckle/operators/object.py

@@ -1,366 +0,0 @@
-"""
-Object operators
-"""
-
-import bpy
-from bpy.props import BoolProperty, EnumProperty
-from deprecated import deprecated
-from bpy_speckle.convert.to_speckle import (
-    convert_to_speckle,
-    ngons_to_speckle_polylines,
-)
-from bpy_speckle.functions import get_scale_length, _report
-from bpy_speckle.clients import speckle_clients
-from specklepy.logging import metrics
-
-@deprecated
-class UpdateObject(bpy.types.Operator):
-    """
-    Update local (receive) or remote (send) object depending on
-    the update direction. If sending, updates the object on the
-    server in-place.
-    """
-
-    bl_idname = "speckle.update_object"
-    bl_label = "Update Object (DEPRECATED)"
-    bl_options = {"REGISTER", "UNDO"}
-
-    client = None
-
-    def execute(self, context):
-        user = context.scene.speckle.users[int(context.scene.speckle.active_user)]
-        client = speckle_clients[int(context.scene.speckle.active_user)]
-
-        active = context.active_object
-        _report(active)
-
-        if active is not None and active.speckle.enabled:
-            if active.speckle.send_or_receive == "send" and active.speckle.stream_id:
-                sstream = client.streams.get(active.speckle.stream_id)
-                # res = client.StreamGetAsync(active.speckle.stream_id)['resource']
-                # res = client.streams.get(active.speckle.stream_id)
-
-                if sstream is None:
-                    _report("Getting stream failed.")
-                    return {"CANCELLED"}
-
-                stream_units = "Meters"
-                if sstream.baseProperties:
-                    stream_units = sstream.baseProperties.units
-
-                scale = context.scene.unit_settings.scale_length / get_scale_length(
-                    stream_units
-                )
-
-                sm = convert_to_speckle(active, scale)
-
-                _report("Updating object {}".format(sm["_id"]))
-                client.objects.update(active.speckle.object_id, sm)
-
-                metrics.track(
-                    "Connector Action",
-                    None, 
-                    custom_props={
-                        "name": "UpdateObject"
-                    },
-                )
-                return {"FINISHED"}
-
-            return {"CANCELLED"}
-        return {"CANCELLED"}
-
-@deprecated
-class ResetObject(bpy.types.Operator):
-    """
-    Reset Speckle object settings
-    """
-
-    bl_idname = "speckle.reset_object"
-    bl_label = "Reset Object (DEPRECATED)"
-    bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context):
-
-        context.object.speckle.send_or_receive = "send"
-        context.object.speckle.stream_id = ""
-        context.object.speckle.object_id = ""
-        context.object.speckle.enabled = False
-        context.view_layer.update()
-
-        metrics.track(
-            "Connector Action",
-            None, 
-            custom_props={
-                "name": "ResetObject"
-            },
-        )
-
-        return {"FINISHED"}
-
-@deprecated
-class DeleteObject(bpy.types.Operator):
-    """
-    Delete object from the server and update relevant stream
-    """
-
-    bl_idname = "speckle.delete_object"
-    bl_label = "Delete Object (DEPRECATED)"
-    bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context):
-        client = speckle_clients[int(context.scene.speckle.active_user)]
-        active = context.object
-        if active.speckle.enabled:
-            res = client.StreamGetAsync(active.speckle.stream_id)
-            existing = [
-                x
-                for x in res["resource"]["objects"]
-                if x["_id"] == active.speckle.object_id
-            ]
-            if existing is None:
-                return {"CANCELLED"}
-            new_objects = [
-                x
-                for x in res["resource"]["objects"]
-                if x["_id"] != active.speckle.object_id
-            ]
-
-            res = client.GetLayers(active.speckle.stream_id)
-            new_layers = res["resource"]["layers"]
-            new_layers[-1]["objectCount"] = new_layers[-1]["objectCount"] - 1
-            new_layers[-1]["topology"] = "0-%s" % new_layers[-1]["objectCount"]
-
-            res = client.StreamUpdateAsync(
-                {"objects": new_objects, "layers": new_layers}, active.speckle.stream_id
-            )
-            res = client.ObjectDeleteAsync(active.speckle.object_id)
-
-            active.speckle.send_or_receive = "send"
-            active.speckle.stream_id = ""
-            active.speckle.object_id = ""
-            active.speckle.enabled = False
-            context.view_layer.update()
-
-            metrics.track(
-                "Connector Action",
-                None, 
-                custom_props={
-                    "name": "DeleteObject"
-                },
-            )
-
-        return {"FINISHED"}
-
-@deprecated
-class UploadNgonsAsPolylines(bpy.types.Operator):
-    """
-    Upload mesh ngon faces as polyline outlines
-    TODO: move to another category of specialized operators and fix to work with API 2.0
-    """
-
-    bl_idname = "speckle.upload_ngons_as_polylines"
-    bl_label = "Upload Ngons As Polylines (DEPRECATED)"
-    bl_options = {"REGISTER", "UNDO"}
-
-    clear_stream: BoolProperty(
-        name="Clear stream",
-        default=False,
-    )
-
-    def execute(self, context):
-        active = context.active_object
-        if active is not None and active.type == "MESH":
-
-            user = context.scene.speckle.users[int(context.scene.speckle.active_user)]
-            client = speckle_clients[int(context.scene.speckle.active_user)]
-            stream = user.streams[user.active_stream]
-
-            # scale = context.scene.unit_settings.scale_length / get_scale_length(
-            #     stream.units
-            # )
-            scale = 1.0
-
-            sp = ngons_to_speckle_polylines(active, scale)
-
-            if sp is None:
-                return {"CANCELLED"}
-
-            placeholders = []
-            for polyline in sp:
-
-                res = client.objects.create([polyline])
-
-                if res is None:
-                    _report(client.me)
-                    continue
-                placeholders.extend(res)
-
-            if not placeholders:
-                return {"CANCELLED"}
-
-                # Get list of existing objects in stream and append new object to list
-            _report("Fetching stream...")
-            sstream = client.streams.get(stream.id)
-
-            if self.clear_stream:
-                _report("Clearing stream...")
-                sstream.objects = placeholders
-                N = 0
-            else:
-                sstream.objects.extend(placeholders)
-
-            N = sstream.layers[-1].objectCount
-            if self.clear_stream:
-                N = 0
-            sstream.layers[-1].objectCount = N + len(placeholders)
-            sstream.layers[-1].topology = "0-%s" % (N + len(placeholders))
-
-            res = client.streams.update(sstream.id, sstream)
-
-            # Update view layer
-            context.view_layer.update()
-            _report("Done.")
-
-            metrics.track(
-                "Connector Action",
-                None, 
-                custom_props={
-                    "name": "UploadNgonsAsPolylines"
-                },
-            )
-        return {"FINISHED"}
-
-    def invoke(self, context, event):
-        wm = context.window_manager
-        return wm.invoke_props_dialog(self)
-
-    def draw(self, context):
-        layout = self.layout
-        layout.prop(self, "clear_stream")
-
-
-def get_custom_speckle_props(self, context):
-    ignore = ["speckle", "cycles", "cycles_visibility"]
-
-    active = context.active_object
-    if not active:
-        return []
-
-    return [(x, "{}".format(x), "") for x in active.keys()]
-
-@deprecated
-class SelectIfSameCustomProperty(bpy.types.Operator):
-    """
-    Select scene objects if they have the same custom property
-    value as the active object
-    """
-
-    bl_idname = "speckle.select_if_same_custom_props"
-    bl_label = "Select Identical Custom Props (DEPRECATED)"
-    bl_options = {"REGISTER", "UNDO"}
-
-    custom_prop: EnumProperty(
-        name="Custom properties",
-        description="Available streams associated with user.",
-        items=get_custom_speckle_props,
-    )
-
-    def draw(self, context):
-        layout = self.layout
-        col = layout.column()
-        col.prop(self, "custom_prop")
-
-    def invoke(self, context, event):
-        wm = context.window_manager
-        return wm.invoke_props_dialog(self)
-
-    def execute(self, context):
-
-        active = context.active_object
-        if not active:
-            return {"CANCELLED"}
-
-        if self.custom_prop not in active.keys():
-            return {"CANCELLED"}
-
-        value = active[self.custom_prop]
-
-        _report(
-            "Looking for '{}' property with a value of '{}'.".format(
-                self.custom_prop, value
-            )
-        )
-
-        for obj in bpy.data.objects:
-
-            if self.custom_prop in obj.keys() and obj[self.custom_prop] == value:
-                obj.select_set(True)
-            else:
-                obj.select_set(False)
-
-            metrics.track(
-                "Connector Action",
-                None, 
-                custom_props={
-                    "name": "SelectIfSameCustomProperty"
-                },
-            )
-                
-        return {"FINISHED"}
-
-@deprecated
-class SelectIfHasCustomProperty(bpy.types.Operator):
-    """
-    Select scene objects if they have the same custom property
-    as the active object, regardless of the value
-    """
-
-    bl_idname = "speckle.select_if_has_custom_props"
-    bl_label = "Select Same Custom Prop (DEPRECATED)"
-    bl_options = {"REGISTER", "UNDO"}
-
-    custom_prop: EnumProperty(
-        name="Custom properties",
-        description="Custom properties yo",
-        items=get_custom_speckle_props,
-    )
-
-    def draw(self, context):
-        layout = self.layout
-        col = layout.column()
-        col.prop(self, "custom_prop")
-
-    def invoke(self, context, event):
-        wm = context.window_manager
-        return wm.invoke_props_dialog(self)
-
-    def execute(self, context):
-
-        active = context.active_object
-        if not active:
-            return {"CANCELLED"}
-
-        if self.custom_prop not in active.keys():
-            return {"CANCELLED"}
-
-        value = active[self.custom_prop]
-
-        _report("Looking for '{}' property.".format(self.custom_prop))
-
-        for obj in bpy.data.objects:
-
-            if self.custom_prop in obj.keys():
-                obj.select_set(True)
-            else:
-                obj.select_set(False)
-
-        metrics.track(
-            "Connector Action",
-            None, 
-            custom_props={
-                "name": "SelectIfHasCustomProperty"
-            },
-        )
-
-
-        return {"FINISHED"}

bpy_speckle/operators/streams.py

@@ -1,864 +0,0 @@
-"""
-Stream operators
-"""
-from math import radians
-from typing import Callable, Dict, Optional, Tuple, Union, cast
-import webbrowser
-import bpy
-from bpy.props import (
-    StringProperty,
-    BoolProperty,
-    EnumProperty,
-)
-from bpy.types import (
-    Context,
-    Object,
-    Collection
-)
-from deprecated import deprecated
-from bpy_speckle.blender_commit_object_builder import BlenderCommitObjectBuilder
-from bpy_speckle.convert.to_native import (
-    can_convert_to_native,
-    collection_to_native,
-    convert_to_native,
-    set_convert_instances_as,
-)
-from bpy_speckle.convert.to_speckle import (
-    convert_to_speckle,
-)
-from bpy_speckle.functions import (
-    get_default_traversal_func,
-    _report,
-    get_scale_length,
-)
-from bpy_speckle.clients import speckle_clients
-from bpy_speckle.operators.users import LoadUserStreams, add_user_stream
-from bpy_speckle.properties.scene import SpeckleSceneSettings, SpeckleStreamObject, SpeckleUserObject, get_speckle, selection_state
-from bpy_speckle.convert.util import ConversionSkippedException, add_to_hierarchy
-from specklepy.core.api.models import Commit
-from specklepy.core.api import operations, host_applications
-from specklepy.core.api.wrapper import StreamWrapper
-from specklepy.core.api.resources.stream import Stream
-from specklepy.transports.server import ServerTransport
-from specklepy.objects import Base
-from specklepy.objects.other import Collection as SCollection
-from specklepy.logging.exceptions import SpeckleException
-from specklepy.logging import metrics
-
-ObjectCallback = Optional[Callable[[bpy.types.Context, Object, Base], Object]]
-ReceiveCompleteCallback = Optional[Callable[[bpy.types.Context, Dict[str, Union[Object, Collection]]], None]]
-
-def get_receive_funcs(speckle: SpeckleSceneSettings) -> tuple[ObjectCallback, ReceiveCompleteCallback]:
-    """
-    Fetches the injected callback functions from user specified "Receive Script"
-    """
-
-    objectCallback: ObjectCallback = None
-    receiveCompleteCallback: ReceiveCompleteCallback = None
-    
-    if speckle.receive_script in bpy.data.texts:
-        mod = bpy.data.texts[speckle.receive_script].as_module()
-        if hasattr(mod, "execute_for_each"):
-            objectCallback = mod.execute_for_each #type: ignore
-        elif hasattr(mod, "execute"): 
-            objectCallback = lambda c, o, _ : mod.execute(c.scene, o) #type: ignore
-
-        if hasattr(mod, "execute_for_all"):
-            receiveCompleteCallback = mod.execute_for_all #type: ignore
-
-    return (objectCallback, receiveCompleteCallback)
-
-#RECEIVE_MODES = [#TODO: modes
-#    ("create", "Create", "Add new geometry, without removing any existing objects"),
-#    ("replace", "Replace", "Replace objects from previous receive operations from the same stream"),
-#    #("update","Update", "") #TODO: update mode!
-#]
-
-INSTANCES_SETTINGS = [
-    ("collection_instance", "Collection Instance", "Receive Instances as Collection Instances"),
-    ("linked_duplicates", "Linked Duplicates", "Receive Instances as Linked Duplicates"),
-]
-
-class ReceiveStreamObjects(bpy.types.Operator):
-    """
-    Receive objects from selected model version
-    """
-
-    bl_idname = "speckle.receive_stream_objects"
-    bl_label = "Receive"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Receive objects from selected model version"
-
-    clean_meshes: BoolProperty(name="Clean Meshes", default=False) # type: ignore 
-
-    #receive_mode: EnumProperty(items=RECEIVE_MODES, name="Receive Type", default="replace", description="The behaviour of the receive operation")
-    receive_instances_as: EnumProperty(items=INSTANCES_SETTINGS, name="Receive Instances As", default="collection_instance", description="How to receive speckle Instances") # type: ignore 
-    
-
-    def draw(self, context):
-        layout = self.layout
-        col = layout.column()
-        col.prop(self, "clean_meshes")
-        #col.prop(self, "receive_mode")
-        col.prop(self, "receive_instances_as")
-
-    def invoke(self, context, event):
-        return context.window_manager.invoke_props_dialog(self)
-
-    @staticmethod
-    def clean_converted_meshes(context: bpy.types.Context, convertedObjects: dict[str, Object]):
-        
-        bpy.ops.object.select_all(action='DESELECT')
-
-        active = None
-        for obj in convertedObjects.values():
-            if obj.type != 'MESH':
-                continue
-
-            obj.select_set(True, view_layer=context.scene.view_layers[0])
-            active = obj
-        
-
-        if active == None:
-            return
-        context.view_layer.objects.active = active
-
-        bpy.ops.object.mode_set(mode='EDIT')
-        bpy.ops.mesh.select_all(action='SELECT')
-        bpy.ops.mesh.dissolve_limited(angle_limit=radians(0.1))
-
-        # Reset state to previous (not quite sure if this is 100% necessary)
-        bpy.ops.object.mode_set(mode='OBJECT')
-        bpy.ops.object.select_all(action='DESELECT')
-        bpy.context.view_layer.objects.active = None # type: ignore 
-
-    def execute(self, context):
-        self.receive(context)
-        return {"FINISHED"}
-
-    def receive(self, context: Context) -> None:
-        bpy.context.view_layer.objects.active = None # type: ignore 
-
-        speckle = get_speckle(context)
-        
-        (user, stream, branch, commit) = speckle.validate_commit_selection()
-        
-        client = speckle_clients[int(speckle.active_user)]
-
-        transport = ServerTransport(stream.id, client)
-        
-        # Fetch commit data
-        commit_object = operations.receive(commit.referenced_object, transport)
-        client.commit.received(
-            stream.id,
-            commit.id,
-            source_application="blender",
-            message="Received model version from Speckle Blender",
-        )
-
-        metrics.track(
-            metrics.RECEIVE,
-            getattr(transport, "account", None), 
-            custom_props={
-                "sourceHostApp": host_applications.get_host_app_from_string(commit.source_application).slug,
-                "sourceHostAppVersion": commit.source_application,
-                "isMultiplayer": commit.author_id != user.id,
-                #"connector_version": "unknown", #TODO
-            },
-        )
-
-
-        # Convert received data
-        context.window_manager.progress_begin(0, commit_object.totalChildrenCount or 1)
-
-        set_convert_instances_as(self.receive_instances_as) #HACK: we need a better way to pass settings down to the converter
-
-        traversalFunc = get_default_traversal_func(can_convert_to_native)
-        converted_objects: Dict[str, Union[Object, Collection]] = {}
-        converted_count: int = 0
-        (object_converted_callback, on_complete_callback) = get_receive_funcs(speckle)
-
-        # older commits will have a non-collection root object
-        # for the sake of consistent behaviour, we will wrap any non-collection commit objects in a collection
-        if not isinstance(commit_object, SCollection):
-            dummy_commit_object = SCollection()
-            dummy_commit_object.elements = [commit_object]
-            dummy_commit_object.name = getattr(commit_object, "name", None)
-            dummy_commit_object.id = dummy_commit_object.get_id()
-            commit_object = dummy_commit_object
-
-        # ensure commit object has a name if not already
-        if not commit_object.name:
-            commit_object.name = f"{stream.name} [ {branch.name} @ {commit.id} ]" # Matches Rhino "Create" naming
-
-        for item in traversalFunc.traverse(commit_object):
-            
-            current: Base = item.current
-
-            if can_convert_to_native(current) or isinstance(current, SCollection):
-                try:
-                    if not current or not current.id:
-                        raise Exception(f"{current} was an invalid Speckle object")
-
-                    #Convert the object!
-                    converted_data_type: str
-                    converted: Union[Object, Collection, None]
-                    if isinstance(current, SCollection):
-                        if(current.collectionType == "Scene Collection"): raise ConversionSkippedException()
-                        converted = collection_to_native(current)
-                        converted_data_type = "COLLECTION"
-                    else:
-                        converted = convert_to_native(current)
-                        converted_data_type = "COLLECTION_INSTANCE" if converted.instance_collection else str(converted.type)
-                        
-                        #Run the user specified callback function (AKA receive script)
-                        if object_converted_callback:
-                            converted = object_converted_callback(context, converted, current)
-                    
-                    if converted is None:
-                        raise Exception("Conversion returned None")
-                        
-                    converted_objects[current.id] = converted
-
-                    add_to_hierarchy(converted, item, converted_objects, True)
-
-                    _report(f"Successfully converted {type(current).__name__} {current.id} as '{converted_data_type}'")
-                except ConversionSkippedException as ex:
-                    _report(f"Skipped converting {type(current).__name__} {current.id}: {ex}")
-                except Exception as ex:
-                    _report(f"Failed to converted {type(current).__name__} {current.id}: {ex}")
-
-            converted_count += 1
-            context.window_manager.progress_update(converted_count) #NOTE: We don't expect to ever reach 100% since not every object will be traversed
-
-
-        context.window_manager.progress_end()
-
-        if self.clean_meshes:
-            objects = {k: v for k, v in converted_objects.items() if isinstance(v, Object)}
-            self.clean_converted_meshes(context, objects)
-
-        if on_complete_callback:
-            on_complete_callback(context, converted_objects)
-
-
-
-class SendStreamObjects(bpy.types.Operator):
-    """
-    Send selected objects to selected model
-    """
-
-    bl_idname = "speckle.send_stream_objects"
-    bl_label = "Send"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Send selected objects to selected model"
-
-    apply_modifiers: BoolProperty(name="Apply modifiers", default=True) # type: ignore 
-    commit_message: StringProperty(
-        name="Message",
-        default="Sent elements from Blender.",
-    ) # type: ignore 
-
-    def draw(self, context):
-        layout = self.layout
-        col = layout.column()
-        col.prop(self, "commit_message")
-        col.prop(self, "apply_modifiers")
-
-    def invoke(self, context, event):
-        wm = context.window_manager
-        speckle = get_speckle(context)
-        if len(speckle.users) <= 0:
-            _report("No user accounts")
-            return {"CANCELLED"}
-        
-        N = len(context.selected_objects)
-        if N == 1:
-            self.commit_message = f"Sent {N} element from Blender."
-        else:
-            self.commit_message = f"Sent {N} elements from Blender."
-        return wm.invoke_props_dialog(self)
-
-
-    def execute(self, context):
-        self.send(context)
-        return {"FINISHED"}
-
-    def send(self, context: Context) -> None:
-
-        selected = context.selected_objects
-        if len(selected) < 1:
-            raise Exception("No objects are selected, sending canceled")
-
-        speckle = get_speckle(context)
-        (user, stream, branch) = speckle.validate_branch_selection()
-
-        client = speckle_clients[int(speckle.active_user)]
-
-        units = "m" if bpy.context.scene.unit_settings.system == "METRIC" else "ft"
-
-        units_scale = context.scene.unit_settings.scale_length / get_scale_length(units)
-
-        # Get script from text editor for injection
-        func = None
-        if speckle.send_script in bpy.data.texts:
-            mod = bpy.data.texts[speckle.send_script].as_module()
-            if hasattr(mod, "execute"):
-                func = mod.execute #type: ignore
-
-        num_converted = 0
-        context.window_manager.progress_begin(0, max(len(selected), 1))
-
-        depsgraph = bpy.context.evaluated_depsgraph_get() if self.apply_modifiers else None
-
-        commit_builder = BlenderCommitObjectBuilder()
-        for obj in selected:
-            try:
-                # Run injected function
-                new_object = obj
-                if func:
-                    new_object = func(context.scene, obj)
-
-                    if (new_object is None):
-                        raise ConversionSkippedException(f"Script '{func.__module__}' returned None.")
-
-                converted = convert_to_speckle(
-                    obj,
-                    units_scale,
-                    units,
-                    depsgraph
-                )
-
-                if not converted:
-                    raise Exception("Converter returned None")
-
-                commit_builder.include_object(converted, obj)
-
-                _report(f"Successfully converted '{obj.name_full}' as '{converted.speckle_type}'")
-            except ConversionSkippedException as ex:
-                _report(f"Skipped converting '{obj.name_full}': '{ex}'")
-            except Exception as ex:
-                _report(f"Failed to converted '{obj.name_full}': '{ex}'")
-                
-            num_converted += 1
-            context.window_manager.progress_update(num_converted)
-
-        context.window_manager.progress_end()
-
-        commit_object = commit_builder.ensure_collection(context.scene.collection)
-        commit_builder.build_commit_object(commit_object)
-
-        metrics.track(
-            metrics.SEND,
-            client.account, 
-            custom_props={
-                "branches": len(stream.branches),
-                #"collaborators": 0, #TODO: 
-                "isMain": branch.name == "main",
-            },
-        )
-    
-        _report(f"Sending data to {stream.name}")
-        transport = ServerTransport(stream.id, client)
-        OBJECT_ID = operations.send(
-            commit_object,
-            [transport],
-        )
-
-        COMMIT_ID = client.commit.create(
-            stream.id,
-            OBJECT_ID,
-            branch.name,
-            message=self.commit_message,
-            source_application="blender",
-        )
-
-        if client.account.serverInfo.frontend2:
-            sent_url = f"{user.server_url}/projects/{stream.id}/models/{branch.id}@{COMMIT_ID}"
-        else:
-            sent_url = f"{user.server_url}/streams/{stream.id}/commits/{COMMIT_ID}"
-
-        _report(f"Commit Created {sent_url}")
-
-        selection_state.selected_commit_id = COMMIT_ID
-        selection_state.selected_branch_id = branch.id
-        selection_state.selected_stream_id = stream.id
-        selection_state.selected_user_id = user.id
-
-        bpy.ops.speckle.load_user_streams() # refresh loaded commits
-        context.view_layer.update()
-
-        if context.area:
-            context.area.tag_redraw()
-
-
-
-class ViewStreamDataApi(bpy.types.Operator):
-    bl_idname = "speckle.view_stream_data_api"
-    bl_label = "Open Model in Web"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "View the selected model in the web browser"
-
-    def execute(self, context):
-        self.view_stream_data_api(context)
-        return {"FINISHED"}
-
-    def view_stream_data_api(self, context: Context) -> None:
-        speckle = get_speckle(context)
-
-        url = self._get_url_from_selection(speckle)
-
-        _report(f"Opening {url} in web browser")
-        
-        if not webbrowser.open(url, new=2):
-            raise Exception(f"Failed to open model in browser ({url})")
-        
-        metrics.track(
-            "Connector Action",
-            None, 
-            custom_props={
-                "name": "view_stream_data_api"
-            },
-        )
-
-    @staticmethod
-    def _get_url_from_selection(speckleScene : SpeckleSceneSettings) -> str:
-
-        client = speckle_clients[int(speckleScene.active_user)]
-        (user, stream) = speckleScene.validate_stream_selection()
-        branch = stream.get_active_branch()
-        commit = branch.get_active_commit() if branch else None
-
-        if client.account.serverInfo.frontend2:
-            server_url = f"{user.server_url}/projects/{stream.id}/"
-            if branch:
-                server_url += f"models/{branch.id}"
-            if commit:
-                server_url += f"@{commit.id}"
-        else:
-            server_url = f"{user.server_url}/streams/{stream.id}/"
-            if commit:
-                server_url += f"commits/{commit.id}"
-            elif branch:
-                server_url += f"branches/{branch.name}"
-
-        return server_url
-    
-class AddStreamFromURL(bpy.types.Operator):
-    """
-    Add / select an existing project by providing its URL
-    """
-
-    bl_idname = "speckle.add_stream_from_url"
-    bl_label = "Add Project From URL"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Add / select an existing project by providing its URL"
-    stream_url: StringProperty(
-        name="Project URL", default=""
-    ) # type: ignore 
-
-    def draw(self, context):
-        layout = self.layout
-        col = layout.column()
-        col.prop(self, "stream_url")
-
-    def invoke(self, context, event):
-        wm = context.window_manager
-        speckle = get_speckle(context)
-        if len(speckle.users) > 0:
-            return wm.invoke_props_dialog(self)
-
-        return {"CANCELLED"}
-
-    def execute(self, context):
-        self.add_stream_from_url(context)
-        return {"FINISHED"}
-
-    @staticmethod
-    def _get_or_add_stream(user : SpeckleUserObject, stream : Stream) -> Tuple[int, SpeckleStreamObject]:
-        index, b_stream = next(
-            ((i, cast(SpeckleStreamObject, s)) for i, s in enumerate(user.streams) if s.id == stream.id),
-            (None, None),
-        )
-
-        if index is not None:
-            assert(b_stream)
-            return (index, b_stream)
-        
-        add_user_stream(user, stream)
-        return next(
-            (i, cast(SpeckleStreamObject, s)) for i, s in enumerate(user.streams) if s.id == stream.id
-        )
-            
-
-    def add_stream_from_url(self, context: Context) -> None:
-        speckle = get_speckle(context)
-
-        wrapper = StreamWrapper(self.stream_url)
-        user_index = next(
-            (i for i, u in enumerate(speckle.users) if wrapper.host in u.server_url),
-            None,
-        )
-        if user_index is None:
-            raise Exception(f"No user account credentials for {wrapper.host}, have you added your account in Manager?")
-        
-        speckle.active_user = str(user_index)
-        user = cast(SpeckleUserObject, speckle.users[user_index])
-
-        client = speckle_clients[user_index]
-        stream = client.stream.get(wrapper.stream_id, branch_limit=LoadUserStreams.branch_limit, commit_limit=LoadUserStreams.commits_limit)
-        if not isinstance(stream, Stream):
-            raise SpeckleException(f"Could not get the requested project {wrapper.stream_id}")
-
-        (index, b_stream) = self._get_or_add_stream(user, stream)
-        user.active_stream = index
-
-        _report(f"Selecting project at index {index} ({b_stream.id} - {b_stream.name})")
-
-        if wrapper.branch_name:
-            b_index = b_stream.branches.find(wrapper.branch_name)
-            b_stream.branch = str(b_index if b_index != -1 else 0)
-        elif wrapper.commit_id:
-            commit = client.commit.get(wrapper.stream_id, wrapper.commit_id)
-            if isinstance(commit, Commit):
-                b_index = b_stream.branches.find(commit.branchName)
-                if b_index == -1:
-                    b_index = 0
-                b_stream.branch = str(b_index)
-                c_index = b_stream.branches[b_index].commits.find(commit.id)
-                b_stream.branches[b_index].commit = str(c_index if c_index != -1 else 0)
-
-        # Update view layer
-        context.view_layer.update()
-
-        if context.area:
-            context.area.tag_redraw()
-        
-        metrics.track(
-            "Connector Action",
-            client.account, 
-            custom_props={
-                "name": "add_stream_from_url"
-            },
-        )
-
-
-class CreateStream(bpy.types.Operator):
-    """
-    Create a new Speckle project using the selected user account
-    """
-
-    bl_idname = "speckle.create_stream"
-    bl_label = "Create Project"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Create a new Speckle project using the selected user account"
-
-    stream_name: StringProperty(name="Project name") # type: ignore 
-    stream_description: StringProperty(
-        name="Project description", default="My new project"
-    ) # type: ignore 
-
-    def draw(self, context):
-        layout = self.layout
-        col = layout.column()
-        col.prop(self, "stream_name")
-        col.prop(self, "stream_description")
-
-    def invoke(self, context, event):
-        wm = context.window_manager
-        speckle = get_speckle(context)
-        if len(speckle.users) > 0:
-            return wm.invoke_props_dialog(self)
-
-        return {"CANCELLED"}
-
-    def execute(self, context):
-        self.create_stream(context)
-        return {"FINISHED"}
-        
-    def create_stream(self, context: Context) -> None:
-        speckle = get_speckle(context)
-
-        user = speckle.validate_user_selection()
-
-        client = speckle_clients[int(speckle.active_user)]
-
-        client.stream.create(
-            name=self.stream_name, 
-            description=self.stream_description, 
-            is_public=True
-        )
-
-        bpy.ops.speckle.load_user_streams()
-        user.active_stream = user.streams.find(self.stream_name)
-
-        # Update view layer
-        context.view_layer.update()
-
-        if context.area:
-            context.area.tag_redraw()
-        
-        metrics.track(
-            "Connector Action",
-            client.account, 
-            custom_props={
-                "name": "create_stream"
-            },
-        )
-
-
-@deprecated
-class DeleteStream(bpy.types.Operator):
-    """
-    Permanently delete the selected project
-    """
-
-    bl_idname = "speckle.delete_stream"
-    bl_label = "Delete Project"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Permanently delete the selected project"
-
-    are_you_sure: BoolProperty(
-        name="Confirm",
-        description="⚠ This action will delete your entire stream permanently ⚠",
-        default=False,
-    ) # type: ignore 
-
-    delete_collection: BoolProperty(name="Delete collection", default=False) # type: ignore 
-
-    def draw(self, context):
-        layout = self.layout
-        col = layout.column()
-        col.prop(self, "are_you_sure")
-        col.prop(self, "delete_collection")
-
-    def invoke(self, context, event):
-        wm = context.window_manager
-        speckle = get_speckle(context)
-        if len(speckle.users) > 0:
-            return wm.invoke_props_dialog(self)
-
-        return {"CANCELLED"}
-
-    def execute(self, context):
-        if not self.are_you_sure:
-            _report(f"Cancelled by user - are_you_sure was {self.are_you_sure}")
-            return {"CANCELLED"}
-        self.are_you_sure = False
-
-        self.delete_stream(context, self.delete_collection)
-        return {"FINISHED"}
-
-    @staticmethod
-    def delete_stream(context: Context, delete_collection: bool) -> None:
-        speckle = get_speckle(context)
-        (_, stream) = speckle.validate_stream_selection()
-
-        client = speckle_clients[int(speckle.active_user)]
-
-        client.stream.delete(id=stream.id)
-
-        if delete_collection:
-            # This may not work anymore since we changed the collection naming...
-            col_name = "SpeckleStream_{}_{}".format(stream.name, stream.id)
-            if col_name in bpy.data.collections:
-                collection = bpy.data.collections[col_name]
-                bpy.data.collections.remove(collection)
-
-        bpy.ops.speckle.load_user_streams()
-        context.view_layer.update()
-
-        if context.area:
-            context.area.tag_redraw()
-
-        metrics.track(
-            "Connector Action",
-            client.account, 
-            custom_props={
-                "name": "delete_stream"
-            },
-        )
-
-@deprecated
-class SelectOrphanObjects(bpy.types.Operator):
-    """
-    Select Speckle objects that don't belong to any stream
-    """
-
-    bl_idname = "speckle.select_orphans"
-    bl_label = "Select Orphaned Objects (DEPRECATED)"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Select Speckle objects that don't belong to any stream"
-
-    def draw(self, context):
-        layout = self.layout
-
-    def execute(self, context):
-
-        for o in context.scene.objects:
-            if (
-                o.speckle.stream_id
-                and o.speckle.stream_id not in context.scene["speckle_streams"]
-            ):
-                o.select = True
-            else:
-                o.select = False
-
-        metrics.track(
-            "Connector Action", 
-            custom_props={
-                "name": "SelectOrphanObjects"
-            },
-        )
-
-        return {"FINISHED"}
-
-class CopyStreamId(bpy.types.Operator):
-    """
-    Copy the selected project id to clipboard
-    """
-
-    bl_idname = "speckle.stream_copy_id"
-    bl_label = "Copy Project Id"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Copy the selected project id to clipboard"
-
-    def execute(self, context):
-        self.copy_stream_id(context)
-        return {"FINISHED"}
-        
-    def copy_stream_id(self, context) -> None:
-        speckle = get_speckle(context)
-
-        (_, stream) = speckle.validate_stream_selection()
-        bpy.context.window_manager.clipboard = stream.id
-
-        metrics.track(
-            "Connector Action",
-            custom_props={
-                "name": "copy_stream_id"
-            },
-        )
-
-class CopyCommitId(bpy.types.Operator):
-    """
-    Copy the selected version id to clipboard
-    """
-
-    bl_idname = "speckle.commit_copy_id"
-    bl_label = "Copy Version Id"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Copy the selected version id to clipboard"
-
-    def execute(self, context):
-        self.copy_commit_id(context)
-        return {"FINISHED"}
-
-        
-    def copy_commit_id(self, context) -> None:
-        speckle = get_speckle(context)
-
-        (_, _, _, commit) = speckle.validate_commit_selection()
-        bpy.context.window_manager.clipboard = commit.id
-
-        metrics.track(
-            "Connector Action",
-            custom_props={
-                "name": "copy_commit_id"
-            },
-        )
-
-
-
-class CopyModelId(bpy.types.Operator):
-    """
-    Copy model id to clipboard
-    """
-
-    bl_idname = "speckle.model_copy_id"
-    bl_label = "Copy model id"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Copy model id to clipboard"
-
-    def execute(self, context):
-        self.copy_model_id(context)
-        return {"FINISHED"}
-
-        
-    def copy_model_id(self, context) -> None:
-        speckle = get_speckle(context)
-
-        (_, _, branch) = speckle.validate_branch_selection()
-
-        bpy.context.window_manager.clipboard = branch.id
-
-        metrics.track(
-            "Connector Action",
-            custom_props={
-                "name": "copy_branch_id"
-            },
-        )
-
-@deprecated
-class CopyBranchName(bpy.types.Operator):
-    """
-    Copy branch name to clipboard
-    """
-
-    bl_idname = "speckle.branch_copy_name"
-    bl_label = "Copy branch name"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Copy branch name to clipboard"
-
-    def execute(self, context):
-        self.copy_branch_id(context)
-        return {"FINISHED"}
-
-        
-    def copy_branch_id(self, context) -> None:
-        speckle = get_speckle(context)
-
-        (_, _, branch) = speckle.validate_branch_selection()
-
-        bpy.context.window_manager.clipboard = branch.name
-
-        metrics.track(
-            "Connector Action",
-            custom_props={
-                "name": "copy_branch_id"
-            },
-        )
-
-@deprecated
-class SelectOrphanObjects(bpy.types.Operator):
-    """
-    Select Speckle objects that don't belong to any stream
-    """
-
-    bl_idname = "speckle.select_orphans"
-    bl_label = "Select orphaned objects"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Select Speckle objects that don't belong to any stream"
-
-    def draw(self, context):
-        layout = self.layout
-
-    def execute(self, context):
-
-        for o in context.scene.objects:
-            if (
-                o.speckle.stream_id
-                and o.speckle.stream_id not in context.scene["speckle_streams"]
-            ):
-                o.select = True
-            else:
-                o.select = False
-
-        metrics.track(
-            "Connector Action", 
-            custom_props={
-                "name": "SelectOrphanObjects"
-            },
-        )
-
-        return {"FINISHED"}

bpy_speckle/operators/users.py

@@ -1,211 +0,0 @@
-"""
-User account operators
-"""
-from typing import List, cast
-import bpy
-from bpy.types import Context
-from bpy_speckle.functions import _report
-from bpy_speckle.clients import speckle_clients
-from bpy_speckle.properties.scene import SpeckleBranchObject, SpeckleCommitObject, SpeckleSceneSettings, SpeckleStreamObject, SpeckleUserObject, get_speckle, restore_selection_state
-from specklepy.core.api.client import SpeckleClient
-from specklepy.core.api.models import Stream
-from specklepy.core.api.credentials import get_local_accounts, Account
-from specklepy.logging import metrics
-
-class ResetUsers(bpy.types.Operator):
-    """
-    Reset loaded users
-    """
-
-    bl_idname = "speckle.users_reset"
-    bl_label = "Reset Users"
-    bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context):
-        self.reset_ui(context)
-
-        metrics.track(
-            "Connector Action",
-            None, 
-            custom_props={
-                "name": "ResetUsers"
-            },
-        )
-
-        bpy.context.view_layer.update()
-        if context.area:
-            context.area.tag_redraw()
-        return {"FINISHED"}
-
-    @staticmethod
-    def reset_ui(context: Context):
-        speckle = get_speckle(context)
-
-        speckle.users.clear()
-        speckle_clients.clear()
-
-class LoadUsers(bpy.types.Operator):
-    """
-    Loads all user accounts from the credentials in the local database.
-    See docs to add accounts via Manager
-    """
-
-    bl_idname = "speckle.users_load"
-    bl_label = "Load Users"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Loads all user accounts from the credentials in the local database.\nSee docs to add accounts via Manager"
-
-    def execute(self, context):
-
-        _report("Loading users...")
-
-        speckle = get_speckle(context)
-        users_list = speckle.users
-
-        ResetUsers.reset_ui(context)
-
-        profiles = get_local_accounts()
-        active_user_index = 0
-
-        metrics.track(
-            "Connector Action",
-            None, 
-            custom_props={
-                "name": "LoadUsers",
-            },
-        )
-
-        if not profiles:
-            raise Exception("Zero accounts were found, please add one through Speckle Manager or a local account")
-
-        for profile in profiles:
-            try:
-                add_user_account(profile, speckle)
-            except Exception as ex:
-                _report(f"Failed to authenticate user account {profile.userInfo.email} with server {profile.serverInfo.url}: {ex}")
-                users_list.remove(len(users_list) - 1)
-                continue
-
-            if profile.isDefault:
-                active_user_index = len(users_list) - 1
-
-        _report(f"Authenticated {len(users_list)}/{len(profiles)} accounts")
-
-        if active_user_index < len(users_list):
-            speckle.active_user = str(active_user_index)
-
-        bpy.context.view_layer.update()
-
-        if context.area:
-            context.area.tag_redraw()
-
-        if not users_list:
-            raise Exception("Zero valid user accounts were found, please ensure account is valid and the server is running")
-
-        return {"FINISHED"}
-
-def add_user_account(account: Account, speckle: SpeckleSceneSettings) -> SpeckleUserObject:
-    """Creates a new new SpeckleUserObject for the provided user Account and adds it to the SpeckleSceneSettings"""
-    users_list = speckle.users
-
-    URL = account.serverInfo.url
-
-    user = cast(SpeckleUserObject, users_list.add())
-    user.server_name = account.serverInfo.name or "Speckle Server"
-    user.server_url = URL
-    user.id = account.userInfo.id
-    user.name = account.userInfo.name
-    user.email = account.userInfo.email
-    user.company = account.userInfo.company or ""
-
-    assert(URL)
-    client = SpeckleClient(
-        host=URL,
-        use_ssl="https" in URL,
-    )
-    client.authenticate_with_account(account)
-    speckle_clients.append(client)
-    return user
-
-
-def add_user_stream(user: SpeckleUserObject, stream: Stream):
-    """Adds the provided Stream (with branch & commits) to the SpeckleUserObject"""
-    s = cast(SpeckleStreamObject, user.streams.add())
-    s.name = stream.name
-    s.id = stream.id
-    s.description = stream.description
-
-    _report(f"Adding stream {s.id} - {s.name}")
-    
-    if stream.branches:
-        s.load_stream_branches(stream)
-
-
-class LoadUserStreams(bpy.types.Operator):
-    """
-    (Re)Load all available projects for active user
-    """
-
-    bl_idname = "speckle.load_user_streams"
-    bl_label = "Load User's Projects"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "(Re)Load all available projects for active user"
-
-    stream_limit: int = 20
-    branch_limit: int = 100
-    commits_limit: int = 10
-
-    def execute(self, context):
-        self.load_user_stream(context)
-        return {"FINISHED"}
-
-        
-    def load_user_stream(self, context: Context) -> None:
-        speckle = get_speckle(context)
-
-        user = speckle.validate_user_selection()
-
-        client = speckle_clients[int(speckle.active_user)]
-        try:
-            streams = client.stream.list(stream_limit=self.stream_limit)
-        except Exception as ex:
-            raise Exception(f"Failed to retrieve projects") from ex
-        
-        if not streams:
-            _report("Zero projects found")
-            return
-
-
-        active_stream_id = None
-        if active_stream := user.get_active_stream():
-            active_stream_id = active_stream.id
-        elif len(user.streams) > 0:
-            active_stream_id = user.streams[0].id
-
-        user.streams.clear()
-
-        for i, s in enumerate(streams):
-            assert(s.id)
-            load_branches = s.id == active_stream_id if active_stream_id else i == 0
-            if load_branches:
-                sstream = client.stream.get(id=s.id, branch_limit=self.branch_limit, commit_limit=10)
-                add_user_stream(user, sstream)
-            else:
-                add_user_stream(user, s)
-
-        restore_selection_state(speckle)
-
-        bpy.context.view_layer.update()
-
-        if context.area:
-            context.area.tag_redraw()
-                
-        metrics.track(
-            "Connector Action",
-            client.account, 
-            custom_props={
-                "name": "LoadUserStreams"
-            },
-        )
-
-

bpy_speckle/properties/__init__.py

@@ -1,23 +0,0 @@
-from .scene import (
-    SpeckleSceneSettings,
-    SpeckleSceneObject,
-    SpeckleUserObject,
-    SpeckleStreamObject,
-    SpeckleBranchObject,
-    SpeckleCommitObject,
-)
-from .object import SpeckleObjectSettings
-from .collection import SpeckleCollectionSettings
-from .addon import SpeckleAddonPreferences
-
-property_classes = [
-    SpeckleSceneObject,
-    SpeckleCommitObject,
-    SpeckleBranchObject,
-    SpeckleStreamObject,
-    SpeckleUserObject,
-    SpeckleSceneSettings,
-    SpeckleObjectSettings,
-    SpeckleCollectionSettings,
-    SpeckleAddonPreferences,
-]

bpy_speckle/properties/addon.py

@@ -1,17 +0,0 @@
-"""
-Addon properties
-"""
-import bpy
-
-
-class SpeckleAddonPreferences(bpy.types.AddonPreferences):
-    """
-    Add-on preferences
-    TODO: add any preferences that might be relevant here
-    """
-
-    bl_idname = __package__
-
-    def draw(self, context):
-        layout = self.layout
-        layout.label(text="SpeckleBlender preferences")

bpy_speckle/properties/collection.py

@@ -1,18 +0,0 @@
-"""
-Collection properties
-"""
-import bpy
-
-
-class SpeckleCollectionSettings(bpy.types.PropertyGroup):
-    enabled: bpy.props.BoolProperty(default=False, name="Enabled") # type: ignore
-
-    send_or_receive: bpy.props.EnumProperty(
-        name="Mode",
-        items=(
-            ("send", "Send", "Send data to Speckle server."),
-            ("receive", "Receive", "Receive data from Speckle server."),
-        ),
-    ) # type: ignore
-    stream_id: bpy.props.StringProperty(default="") # type: ignore
-    name: bpy.props.StringProperty(default="") # type: ignore

bpy_speckle/properties/object.py

@@ -1,18 +0,0 @@
-"""
-Object properties
-"""
-import bpy
-
-
-class SpeckleObjectSettings(bpy.types.PropertyGroup):
-    enabled: bpy.props.BoolProperty(default=False, name="Enabled")
-
-    send_or_receive: bpy.props.EnumProperty(
-        name="Mode",
-        items=(
-            ("send", "Send", "Send data to Speckle server."),
-            ("receive", "Receive", "Receive data from Speckle server."),
-        ),
-    ) # type: ignore
-    stream_id: bpy.props.StringProperty(default="") # type: ignore
-    object_id: bpy.props.StringProperty(default="") # type: ignore

bpy_speckle/properties/scene.py

@@ -1,311 +0,0 @@
-"""
-Scene properties
-"""
-from typing import Iterable, Optional, Tuple, Union, cast
-from dataclasses import dataclass
-import bpy
-from bpy.props import (
-    StringProperty,
-    FloatProperty,
-    CollectionProperty,
-    EnumProperty,
-    IntProperty,
-)
-
-from bpy_speckle.clients import speckle_clients
-from specklepy.core.api.models import Stream
-
-class SpeckleSceneObject(bpy.types.PropertyGroup):
-    name: bpy.props.StringProperty(default="") # type: ignore
-
-
-class SpeckleCommitObject(bpy.types.PropertyGroup):
-    id: StringProperty(default="") # type: ignore
-    message: StringProperty(default="") # type: ignore
-    author_name: StringProperty(default="") # type: ignore
-    author_id: StringProperty(default="") # type: ignore
-    created_at: StringProperty(default="") # type: ignore
-    source_application: StringProperty(default="") # type: ignore
-    referenced_object: StringProperty(default="") # type: ignore
-
-
-class SpeckleBranchObject(bpy.types.PropertyGroup):
-    def get_commits(self, context):
-        if self.commits != None and len(self.commits) > 0:
-            COMMITS = cast(Iterable[SpeckleCommitObject], self.commits)
-            return [
-                (str(i), commit.id, commit.message, i)
-                for i, commit in enumerate(COMMITS)
-            ]
-        return [("0", "<none>", "<none>", 0)]
-  
-    def commit_update_hook(self, context: bpy.types.Context):
-        selection_state.selected_commit_id = SelectionState.get_item_id_by_index(self.commits, self.commit)
-        selection_state.selected_branch_id = self.id
-        # print(f"commit_update_hook: {selection_state.selected_commit_id=}, {selection_state.selected_branch_id=}")
-
-    name: StringProperty(default="main") # type: ignore
-    id: StringProperty(default="") # type: ignore
-    description: StringProperty(default="") # type: ignore
-    commits: CollectionProperty(type=SpeckleCommitObject) # type: ignore
-    commit: EnumProperty(
-        name="Version",
-        description="Selected model version",
-        items=get_commits,
-        update=commit_update_hook,
-    ) # type: ignore
-    
-    def get_active_commit(self) -> Optional[SpeckleCommitObject]:
-        selected_index = int(self.commit)
-        if 0 <= selected_index < len(self.commits): 
-            return self.commits[selected_index]
-        return None
-    
-class SpeckleStreamObject(bpy.types.PropertyGroup):
-    def load_stream_branches(self, sstream: Stream):
-        self.branches.clear()
-        # branches = [branch for branch in stream.branches.items if branch.name != "globals"]
-        for b in sstream.branches.items:
-            branch = cast(SpeckleBranchObject, self.branches.add())
-            branch.name = b.name
-            branch.id = b.id
-            branch.description = b.description or ""
-
-            if not b.commits:
-                continue
-
-            for c in b.commits.items:
-                commit: SpeckleCommitObject = branch.commits.add()
-                commit.id = commit.name = c.id
-                commit.message = c.message or ""
-                commit.author_name = c.authorName
-                commit.author_id = c.authorId
-                commit.created_at = c.createdAt.strftime("%Y-%m-%d %H:%M:%S.%f%Z") if c.createdAt else ""
-                commit.source_application = str(c.sourceApplication)
-                commit.referenced_object = c.referencedObject
-
-    def get_branches(self, context):
-        if self.branches:
-            BRANCHES = cast(Iterable[SpeckleBranchObject], self.branches)
-            return [
-                (str(i), branch.name, branch.description, i)
-                for i, branch in enumerate(BRANCHES)
-                if branch.name != "globals"
-            ]
-        return [("0", "<none>", "<none>", 0)]
-    
-    def branch_update_hook(self, context: bpy.types.Context):
-        selection_state.selected_branch_id = SelectionState.get_item_id_by_index(self.branches, self.branch)
-        # print(f"branch_update_hook: {selection_state.selected_branch_id=}, {selection_state.selected_stream_id=}")
-
-    name: StringProperty(default="") # type: ignore
-    description: StringProperty(default="") # type: ignore
-    id: StringProperty(default="") # type: ignore
-    branches: CollectionProperty(type=SpeckleBranchObject) # type: ignore
-    branch: EnumProperty(
-        name="Model",
-        description="Selected Model",
-        items=get_branches,
-        update=branch_update_hook,
-    ) # type: ignore
-
-    def get_active_branch(self) -> Optional[SpeckleBranchObject]:
-        selected_index = int(self.branch)
-        if 0 <= selected_index < len(self.branches): 
-            return self.branches[selected_index]
-        return None
-
-class SpeckleUserObject(bpy.types.PropertyGroup):
-    def fetch_stream_branches(self, context: bpy.types.Context, stream: SpeckleStreamObject):
-        speckle = context.scene.speckle
-        client = speckle_clients[int(speckle.active_user)]
-        sstream = client.stream.get(id=stream.id, branch_limit=100, commit_limit=10) # TODO: refactor magic numbers
-        stream.load_stream_branches(sstream)
-
-    def stream_update_hook(self, context: bpy.types.Context):
-        stream = SelectionState.get_item_by_index(self.streams, self.active_stream)
-        selection_state.selected_stream_id = stream.id
-        # print(f"stream_update_hook: {selection_state.selected_stream_id=}, {selection_state.selected_user_id=}")
-        if len(stream.branches) == 0: # do not reload on selection, same as the old behavior 
-            self.fetch_stream_branches(context, stream)
-
-    server_name: StringProperty(default="SpeckleXYZ") # type: ignore
-    server_url: StringProperty(default="https://speckle.xyz") # type: ignore
-    id: StringProperty(default="") # type: ignore
-    name: StringProperty(default="Speckle User") # type: ignore
-    email: StringProperty(default="user@speckle.xyz") # type: ignore
-    company: StringProperty(default="SpeckleSystems") # type: ignore
-    streams: CollectionProperty(type=SpeckleStreamObject) # type: ignore
-    active_stream: IntProperty(default=0, update=stream_update_hook) # type: ignore
-
-    def get_active_stream(self) -> Optional[SpeckleStreamObject]:
-        selected_index = int(self.active_stream)
-        if 0 <= selected_index < len(self.streams): 
-            return self.streams[selected_index]
-        return None
-    
-
-class SpeckleSceneSettings(bpy.types.PropertyGroup):
-    def get_scripts(self, context):
-        return [
-            ("<none>", "<none>", "<none>"),
-            *[(t.name, t.name, t.name) for t in bpy.data.texts],
-        ]
-
-    streams: EnumProperty(
-        name="Available streams",
-        description="Available streams associated with user.",
-        items=[],
-    ) # type: ignore
-
-    users: CollectionProperty(type=SpeckleUserObject) # type: ignore
-
-    def get_users(self, context):
-        USERS = cast(Iterable[SpeckleUserObject], self.users)
-        return [
-            (str(i), f"{user.email} ({user.server_name})", user.server_url, i)
-            for i, user in enumerate(USERS)
-        ]
-
-    def user_update_hook(self, context):
-        bpy.ops.speckle.load_user_streams() # type: ignore
-        selection_state.selected_user_id = SelectionState.get_item_id_by_index(self.users, self.active_user)
-
-    active_user: EnumProperty(
-        items=get_users,
-        name="Account",
-        description="Select account",
-        update=user_update_hook,
-        get=None,
-        set=None,
-    ) # type: ignore
-
-    objects: CollectionProperty(type=SpeckleSceneObject) # type: ignore
-
-    scale: FloatProperty(default=0.001) # type: ignore
-
-    user: StringProperty(
-        name="User",
-        description="Current user",
-        default="Speckle User",
-    ) # type: ignore
-
-    receive_script: EnumProperty(
-        name="Receive script",
-        description="Custom py script to execute when receiving objects. See docs for function signature.",
-        items=get_scripts,
-    ) # type: ignore
-
-    send_script: EnumProperty(
-        name="Send script",
-        description="Custom py script to execute when sending objects. See docs for function signature",
-        items=get_scripts,
-    ) # type: ignore
-
-    def get_active_user(self) -> Optional[SpeckleUserObject]:
-        if self.active_user is None:
-            return None
-        selected_index = int(self.active_user)
-        if 0 <= selected_index < len(self.users):
-            return self.users[selected_index]
-        return None
-    
-
-    def validate_user_selection(self) -> SpeckleUserObject:
-        user = self.get_active_user()
-        if not user:
-            raise SelectionException("No user account selected/found")
-        return user
-        
-    def validate_stream_selection(self) -> Tuple[SpeckleUserObject, SpeckleStreamObject]:
-        user = self.validate_user_selection()
-
-        stream = user.get_active_stream()
-        if not stream:
-            raise SelectionException("No project selected/found")
-
-        return (user, stream)
-    
-    def validate_branch_selection(self) -> Tuple[SpeckleUserObject, SpeckleStreamObject, SpeckleBranchObject]:
-        (user, stream) = self.validate_stream_selection()
-
-        branch = stream.get_active_branch()
-        if not branch:
-            raise SelectionException("No model selected/found")
-        return (user, stream, branch)
-    
-    def validate_commit_selection(self) ->Tuple[SpeckleUserObject, SpeckleStreamObject, SpeckleBranchObject, SpeckleCommitObject]:
-        (user, stream, branch) = self.validate_branch_selection()
-        commit = branch.get_active_commit()
-        if commit is None:
-            raise SelectionException("No model version selected/found")
-        
-        return (user, stream, branch, commit)
-    
-class SelectionException(Exception):
-    pass
-
-def get_speckle(context: bpy.types.Context) -> SpeckleSceneSettings:
-    """
-    Gets the speckle scene object
-    """
-    return context.scene.speckle #type: ignore
-
-@dataclass
-class SelectionState:
-    selected_user_id : Optional[str] = None
-    selected_stream_id : Optional[str] = None
-    selected_branch_id : Optional[str] = None
-    selected_commit_id : Optional[str] = None
-
-    @staticmethod
-    def get_item_id_by_index(collection: bpy.types.PropertyGroup, index: Union[str, int]) -> Optional[str]:
-        if item := SelectionState.get_item_by_index(collection, index):
-            return item.id
-        return None
-    
-    @staticmethod
-    def get_item_by_index(collection: bpy.types.PropertyGroup, index: Union[str, int]) -> Optional[bpy.types.PropertyGroup]:
-        items = collection.values()
-        i = int(index)
-        if 0 <= i <= len(items):
-            return items[i]
-        return None
-    
-    @staticmethod
-    def get_item_index_by_id(collection: Iterable[SpeckleCommitObject], id: Optional[str]) -> Optional[str]:
-        for index, item in enumerate(collection):
-            if item.id == id:
-                return str(index)
-        return None
-
-selection_state = SelectionState()
-
-def restore_selection_state(speckle: SpeckleSceneSettings) -> None:
-    # Restore branch selection state
-    if selection_state.selected_branch_id != None:
-        (active_user, active_stream) = speckle.validate_stream_selection()
-        # print(f"restore_selection_state: {active_user.id=}, {active_stream.id=}")
-        # print(f"restore_selection_state: {selection_state.selected_user_id=}, {selection_state.selected_stream_id=}, {selection_state.selected_branch_id=}, {selection_state.selected_commit_id=}")
-
-        is_same_user = active_user.id == selection_state.selected_user_id
-    
-        if is_same_user:
-            active_user.active_stream = int(SelectionState.get_item_index_by_id(active_user.streams, selection_state.selected_stream_id))
-            active_stream = SelectionState.get_item_by_index(active_user.streams, active_user.active_stream)
-            if branch := SelectionState.get_item_index_by_id(active_stream.branches, selection_state.selected_branch_id):
-                active_stream.branch = branch
-    
-    # Restore commit selection state
-    if selection_state.selected_commit_id != None:
-        (active_user, active_stream, active_branch) = speckle.validate_branch_selection()
-        # print(f"restore_selection_state: {active_user.id=}, {active_stream.id=}, {active_branch.id=}")
-        # print(f"restore_selection_state: {selection_state.selected_user_id=}, {selection_state.selected_stream_id=}, {selection_state.selected_branch_id=}, {selection_state.selected_commit_id=}")
-
-        is_same_user = active_user.id == selection_state.selected_user_id
-        is_same_stream = active_stream.id == selection_state.selected_stream_id
-        is_same_branch = active_branch.id == selection_state.selected_branch_id
-
-        if is_same_user and is_same_stream and is_same_branch:
-            if commit := SelectionState.get_item_index_by_id(active_branch.commits, selection_state.selected_commit_id):
-                active_branch.commit = commit

bpy_speckle/speckle_blender_addon.code-workspace

@@ -0,0 +1,14 @@
+{
+	"folders": [
+		{
+			"path": ".."
+		},
+		{
+			"name": "speckle_blender_addon",
+			"path": "."
+		}
+	],
+	"settings": {
+		"blender.addon.loadDirectory": "auto"
+	}
+}

bpy_speckle/ui/__init__.py

@@ -1,18 +0,0 @@
-from .object import OBJECT_PT_speckle
-from .view3d import (
-    VIEW3D_UL_SpeckleUsers,
-    VIEW3D_UL_SpeckleStreams,
-    VIEW3D_PT_SpeckleUser,
-    VIEW3D_PT_SpeckleStreams,
-    VIEW3D_PT_SpeckleActiveStream,
-    VIEW3D_PT_SpeckleHelp,
-)
-
-ui_classes = [
-    VIEW3D_PT_SpeckleUser,
-    VIEW3D_PT_SpeckleStreams,
-    VIEW3D_PT_SpeckleActiveStream,
-    VIEW3D_UL_SpeckleUsers,
-    VIEW3D_UL_SpeckleStreams,
-    VIEW3D_PT_SpeckleHelp,
-]

bpy_speckle/ui/object.py

@@ -1,36 +0,0 @@
-"""
-Object UI elements
-"""
-
-import bpy
-from bpy.props import (
-    StringProperty,
-    BoolProperty,
-    FloatProperty,
-    CollectionProperty,
-    EnumProperty,
-)
-from deprecated import deprecated
-
-@deprecated
-class OBJECT_PT_speckle(bpy.types.Panel):
-    bl_space_type = "PROPERTIES"
-    # bl_idname = 'OBJECT_PT_speckle'
-    bl_region_type = "WINDOW"
-    bl_context = "object"
-    bl_label = "Speckle"
-
-    def draw_header(self, context):
-        self.layout.prop(context.object.speckle, "enabled", text="")
-
-    def draw(self, context):
-        ob = context.object
-        layout = self.layout
-        layout.active = ob.speckle.enabled
-        col = layout.column()
-        col.prop(ob.speckle, "send_or_receive", expand=True)
-        col.prop(ob.speckle, "stream_id", text="Project ID")
-        col.prop(ob.speckle, "object_id", text="Object ID")
-        col.operator("speckle.update_object", text="Update")
-        col.operator("speckle.reset_object", text="Reset")
-        col.operator("speckle.delete_object", text="Delete")

bpy_speckle/ui/view3d.py

@@ -1,260 +0,0 @@
-"""
-Speckle UI elements for the 3d viewport
-"""
-
-
-import bpy
-
-from datetime import datetime
-
-from bpy_speckle.properties.scene import get_speckle
-
-Region = "TOOLS" if bpy.app.version < (2, 80, 0) else "UI"
-
-
-def wrap(width, text):
-    """
-    Split strings into width for
-    wrapping
-    """
-    lines = []
-
-    arr = text.split()
-    lengthSum = 0
-
-    line = []
-    for var in arr:
-        lengthSum += len(var) + 1
-        if lengthSum <= width:
-            line.append(var)
-        else:
-            lines.append(" ".join(line))
-            line = [var]
-            lengthSum = len(var)
-
-    lines.append(" ".join(line))
-
-    return lines
-
-
-def get_available_users(self, context):
-    """
-    Function to populate users list
-    """
-    return [(a, a, a.name) for a in context.scene.speckle.users]
-
-
-class VIEW3D_UL_SpeckleUsers(bpy.types.UIList):
-    """
-    Speckle user list
-    """
-
-    def draw_item(self, context, layout, data, user, active_data, active_propname):
-        if self.layout_type in {"DEFAULT", "COMPACT"}:
-            if user:
-                # layout.prop(user, "name", text=user.name, emboss=False, icon_value=0)
-                layout.label(
-                    text=user.name + " (" + user.email + ")",
-                    translate=False,
-                    icon_value=0,
-                )
-            else:
-                layout.label(text="", translate=False, icon_value=0)
-
-        elif self.layout_type in {"GRID"}:
-            layout.alignment = "CENTER"
-            layout.label(text="Users", icon_value=0)
-
-
-class VIEW3D_UL_SpeckleStreams(bpy.types.UIList):
-    """
-    Speckle projects list
-    """
-
-    def draw_item(self, context, layout, data, stream, active_data, active_propname):
-        if self.layout_type in {"DEFAULT", "COMPACT"}:
-            if stream:
-                layout.label(
-                    text=f"{stream.name} ({stream.id})",
-                    translate=False,
-                    icon_value=0,
-                )
-            else:
-                layout.label(text=" ", translate=False, icon_value=0)
-
-        elif self.layout_type in {"GRID"}:
-            layout.alignment = "CENTER"
-            layout.label(text="Projects", icon_value=0)
-
-
-class VIEW3D_PT_SpeckleUser(bpy.types.Panel):
-    """
-    Speckle Users UI panel in the 3d viewport
-    """
-
-    bl_space_type = "VIEW_3D"
-    bl_region_type = Region
-    bl_category = "Speckle"
-    bl_context = "objectmode"
-    bl_label = "User Account"
-
-    def draw(self, context):
-        speckle = get_speckle(context)
-
-        layout = self.layout
-        col = layout.column()
-
-        if len(speckle.users) < 1:
-            col.label(text="Refresh to initialise")
-        else:
-            col.prop(speckle, "active_user", text="")
-            user = speckle.users[int(speckle.active_user)]
-            col.label(text=f"{user.server_name} ({user.server_url})")
-            col.label(text=f"{user.name} ({user.email})")
-
-        col.operator("speckle.users_load", text="", icon="FILE_REFRESH")
-
-class VIEW3D_PT_SpeckleStreams(bpy.types.Panel):
-    """
-    Speckle projects UI panel in the 3d viewport
-    """
-
-    bl_space_type = "VIEW_3D"
-    bl_region_type = Region
-    bl_category = "Speckle"
-    bl_context = "objectmode"
-    bl_label = "Projects"
-
-    def draw(self, context):
-        speckle = get_speckle(context)
-        col = self.layout.column()
-
-        if len(speckle.users) < 1:
-            col.label(text="No Projects")
-        else:
-            user = speckle.users[int(speckle.active_user)]
-            col.template_list(
-                "VIEW3D_UL_SpeckleStreams", "", user, "streams", user, "active_stream"
-            )
-            row = col.row(align=True)
-            row.operator("speckle.add_stream_from_url", text="", icon="URL")
-            row.operator("speckle.create_stream", text="", icon="ADD")
-            row.operator("speckle.load_user_streams", text="", icon="FILE_REFRESH")
-
-
-class VIEW3D_PT_SpeckleActiveStream(bpy.types.Panel):
-    """
-    Speckle Active Projects UI panel in the 3d viewport
-    """
-
-    bl_space_type = "VIEW_3D"
-    bl_region_type = Region
-    bl_category = "Speckle"
-    bl_context = "objectmode"
-    bl_label = "Active Project"
-
-    def draw(self, context):
-        speckle = get_speckle(context)
-        col = self.layout.column()
-
-        if len(speckle.users) < 1:
-            col.label(text="No projects")
-        else:
-            user = speckle.validate_user_selection()
-            #user = speckle.users[int(speckle.active_user)]
-            if len(user.streams) < 1:
-                col.label(text="No active project")
-            else:
-                stream = user.streams[user.active_stream]
-                # user.active_stream = min(user.active_stream, len(user.streams) - 1)
-                row = col.row()
-                row.label(text=f"{stream.name} ({stream.id})")
-                row.operator("speckle.stream_copy_id", text="", icon="COPY_ID")
-                col.separator()
-
-                row = col.row()
-                row.prop(stream, "branch", text="Model")
-                row.operator("speckle.model_copy_id", text="", icon="COPY_ID")
-
-                if len(stream.branches) > 0:
-                    branch = stream.branches[int(stream.branch)]
-
-                    row = col.row()
-                    row.prop(branch, "commit", text="Version")
-                    row.operator("speckle.commit_copy_id", text="", icon="COPY_ID")
-
-                    if len(branch.commits) > 0:
-                        commit = branch.commits[int(branch.commit)]
-                        area = col.box()
-                        area.separator()
-
-                        lines = wrap(32, commit.message)
-                        for line in lines:
-                            row = area.row(align=True)
-                            row.alignment = "EXPAND"
-                            row.scale_y = 0.4
-                            row.label(text=line)
-                        area.separator()
-
-                        dt = datetime.strptime(
-                            commit.created_at, "%Y-%m-%d %H:%M:%S.%f%Z"
-                        )
-                        col.label(text=f"{dt.ctime()}")
-                        col.label(text=f"{commit.author_name} ({commit.author_id})")
-                        col.label(text=commit.source_application)
-                else:
-                    col.label(text="No models found!")
-
-                col.separator()
-
-                area = col.box()
-                row = area.row()
-                subcol = row.column()
-                subcol.operator("speckle.receive_stream_objects", text="Receive")
-                subcol.prop(speckle, "receive_script", text="")
-                subcol = row.column()
-                subcol.operator("speckle.send_stream_objects", text="Send")
-                subcol.prop(speckle, "send_script", text="")
-
-                col.separator()
-
-                row = col.row(align=True)
-                subcol = row.column()
-
-                col.label(text="Description:")
-                area = col.box()
-                area.separator()
-
-                lines = wrap(32, stream.description)
-
-                for line in lines:
-                    row = area.row(align=True)
-                    row.alignment = "EXPAND"
-                    row.scale_y = 0.4
-                    row.label(text=line)
-
-                area.separator()
-                col.separator()
-                col.operator("speckle.view_stream_data_api", text="Open Model in Web")
-
-
-class VIEW3D_PT_SpeckleHelp(bpy.types.Panel):
-    """
-    Speckle Help UI panel in the 3d viewport
-    """
-
-    bl_space_type = "VIEW_3D"
-    bl_region_type = Region
-    bl_category = "Speckle"
-    bl_context = "objectmode"
-    bl_label = "Help"
-
-    def draw(self, context):
-        layout = self.layout
-        col = layout.column()
-
-        col.operator("speckle.open_speckle_guide")
-        col.separator()
-        col.operator("speckle.open_speckle_tutorials")
-        col.separator()
-        col.operator("speckle.open_speckle_forum")

bpy_speckle/util.py

@@ -1,54 +0,0 @@
-def find_key_case_insensitive(data, key, default=None):
-    value = data.get(key)
-    if value:
-        return value
-
-    """
-    Necessary to find keys where the first character
-    is capitalized
-    """
-    value = data.get(key[0].upper() + key[1:])
-    if value:
-        return value
-
-    value = data.get(key.upper())
-    if value:
-        return value
-
-    return default
-
-
-def get_iddata(base, uuid, name, obdata):
-    """
-    This is taken from the import_3dm add-on:
-    https://github.com/jesterKing/import_3dm
-    # Copyright (c) 2018-2019 Nathan Letwory, Joel Putnam, 
-    Tom Svilans
-
-    Get an iddata. If an object with given uuid is found in
-    this .blend use that. Otherwise new up one with base.new,
-    potentially with obdata if that is set
-    """
-    founditem = None
-    if uuid is not None:
-        for item in base:
-            if item.get("speckle_id", None) == str(uuid):
-                founditem = item
-                break
-    elif name:
-        for item in base:
-            if item.get("name", None) == name:
-                founditem = item
-                break
-    if founditem:
-        theitem = founditem
-        theitem["name"] = name
-        if obdata:
-            theitem.data = obdata
-    else:
-        if obdata:
-            theitem = base.new(name=name, object_data=obdata)
-        else:
-            theitem = base.new(name=name)
-        tag_data(theitem, uuid, name)
-    return theitem

export_dependencies.sh

@@ -1,4 +1,4 @@
 #!/usr/bin/env bash
 set -e -o pipefail
 
-poetry export --only main -o bpy_speckle/requirements.txt
+uv pip compile pyproject.toml --output-file bpy_speckle/requirements.txt --all-extras

pyproject.toml

@@ -1,24 +1,16 @@
-[tool.poetry]
+[project]
 name = "speckle-blender"
-version = "2.0.0"
-description = "the Speckle 2.0 connector for Blender!"
-authors = ["izzy lyseggen <izzy.lyseggen@gmail.com>", "Gergő Jedlicska <gergo@jedlicska.com>"]
+version = "3.0.0"
+description = "Next-Gen Speckle connector for Blender!"
+requires-python = ">=3.11.9, <4.0.0"
 license = "Apache-2.0"
+dependencies = [
+    "specklepy>=3.0.0a3"
+]
 
-[tool.poetry.dependencies]
-python = ">=3.8, <4.0.0"
-specklepy = "^2.19.1"
-attrs = "^23.1.0"
+[dependency-groups]
+dev = [
+    "fake-bpy-module-latest>=20240524,<20240525",
+    "ruff>=0.4.4,<0.5",
+]
 
-# [tool.poetry.group.local_specklepy.dependencies]
-# specklepy = {path = "../specklepy", develop = true}
-
-[tool.poetry.group.dev.dependencies]
-fake-bpy-module-latest = "^20240524"
-black = "23.11.0"
-pylint = "^2.15.7"
-ruff = "^0.4.4"
-
-[build-system]
-requires = ["poetry-core>=1.0.0"]
-build-backend = "poetry.core.masonry.api"

uv.lock

@@ -0,0 +1,707 @@
+version = 1
+revision = 1
+requires-python = ">=3.11.9, <4.0.0"
+
+[[package]]
+name = "annotated-types"
+version = "0.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643 },
+]
+
+[[package]]
+name = "anyio"
+version = "4.5.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "idna" },
+    { name = "sniffio" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/4d/f9/9a7ce600ebe7804daf90d4d48b1c0510a4561ddce43a596be46676f82343/anyio-4.5.2.tar.gz", hash = "sha256:23009af4ed04ce05991845451e11ef02fc7c5ed29179ac9a420e5ad0ac7ddc5b", size = 171293 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1b/b4/f7e396030e3b11394436358ca258a81d6010106582422f23443c16ca1873/anyio-4.5.2-py3-none-any.whl", hash = "sha256:c011ee36bc1e8ba40e5a81cb9df91925c218fe9b778554e0b56a21e1b5d4716f", size = 89766 },
+]
+
+[[package]]
+name = "appdirs"
+version = "1.4.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d7/d8/05696357e0311f5b5c316d7b95f46c669dd9c15aaeecbb48c7d0aeb88c40/appdirs-1.4.4.tar.gz", hash = "sha256:7d5d0167b2b1ba821647616af46a749d1c653740dd0d2415100fe26e27afdf41", size = 13470 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3b/00/2344469e2084fb287c2e0b57b72910309874c3245463acd6cf5e3db69324/appdirs-1.4.4-py2.py3-none-any.whl", hash = "sha256:a841dacd6b99318a741b166adb07e19ee71a274450e68237b4650ca1055ab128", size = 9566 },
+]
+
+[[package]]
+name = "attrs"
+version = "25.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/69/82/3c4e1d44f3cbaa2a578127d641fe385ba3bff6c38b789447ae11a21fa413/attrs-25.2.0.tar.gz", hash = "sha256:18a06db706db43ac232cce80443fcd9f2500702059ecf53489e3c5a3f417acaf", size = 812038 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/03/33/7a7388b9ef94aab40539939d94461ec682afbd895458945ed25be07f03f6/attrs-25.2.0-py3-none-any.whl", hash = "sha256:611344ff0a5fed735d86d7784610c84f8126b95e549bcad9ff61b4242f2d386b", size = 64016 },
+]
+
+[[package]]
+name = "backoff"
+version = "2.2.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/47/d7/5bbeb12c44d7c4f2fb5b56abce497eb5ed9f34d85701de869acedd602619/backoff-2.2.1.tar.gz", hash = "sha256:03f829f5bb1923180821643f8753b0502c3b682293992485b0eef2807afa5cba", size = 17001 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/df/73/b6e24bd22e6720ca8ee9a85a0c4a2971af8497d8f3193fa05390cbd46e09/backoff-2.2.1-py3-none-any.whl", hash = "sha256:63579f9a0628e06278f7e47b7d7d5b6ce20dc65c5e96a6f3ca99a6adca0396e8", size = 15148 },
+]
+
+[[package]]
+name = "certifi"
+version = "2024.8.30"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b0/ee/9b19140fe824b367c04c5e1b369942dd754c4c5462d5674002f75c4dedc1/certifi-2024.8.30.tar.gz", hash = "sha256:bec941d2aa8195e248a60b31ff9f0558284cf01a52591ceda73ea9afffd69fd9", size = 168507 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/12/90/3c9ff0512038035f59d279fddeb79f5f1eccd8859f06d6163c58798b9487/certifi-2024.8.30-py3-none-any.whl", hash = "sha256:922820b53db7a7257ffbda3f597266d435245903d80737e34f8a45ff3e3230d8", size = 167321 },
+]
+
+[[package]]
+name = "charset-normalizer"
+version = "3.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f2/4f/e1808dc01273379acc506d18f1504eb2d299bd4131743b9fc54d7be4df1e/charset_normalizer-3.4.0.tar.gz", hash = "sha256:223217c3d4f82c3ac5e29032b3f1c2eb0fb591b72161f86d93f5719079dae93e", size = 106620 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9c/61/73589dcc7a719582bf56aae309b6103d2762b526bffe189d635a7fcfd998/charset_normalizer-3.4.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:0d99dd8ff461990f12d6e42c7347fd9ab2532fb70e9621ba520f9e8637161d7c", size = 193339 },
+    { url = "https://files.pythonhosted.org/packages/77/d5/8c982d58144de49f59571f940e329ad6e8615e1e82ef84584c5eeb5e1d72/charset_normalizer-3.4.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c57516e58fd17d03ebe67e181a4e4e2ccab1168f8c2976c6a334d4f819fe5944", size = 124366 },
+    { url = "https://files.pythonhosted.org/packages/bf/19/411a64f01ee971bed3231111b69eb56f9331a769072de479eae7de52296d/charset_normalizer-3.4.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:6dba5d19c4dfab08e58d5b36304b3f92f3bd5d42c1a3fa37b5ba5cdf6dfcbcee", size = 118874 },
+    { url = "https://files.pythonhosted.org/packages/4c/92/97509850f0d00e9f14a46bc751daabd0ad7765cff29cdfb66c68b6dad57f/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bf4475b82be41b07cc5e5ff94810e6a01f276e37c2d55571e3fe175e467a1a1c", size = 138243 },
+    { url = "https://files.pythonhosted.org/packages/e2/29/d227805bff72ed6d6cb1ce08eec707f7cfbd9868044893617eb331f16295/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ce031db0408e487fd2775d745ce30a7cd2923667cf3b69d48d219f1d8f5ddeb6", size = 148676 },
+    { url = "https://files.pythonhosted.org/packages/13/bc/87c2c9f2c144bedfa62f894c3007cd4530ba4b5351acb10dc786428a50f0/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8ff4e7cdfdb1ab5698e675ca622e72d58a6fa2a8aa58195de0c0061288e6e3ea", size = 141289 },
+    { url = "https://files.pythonhosted.org/packages/eb/5b/6f10bad0f6461fa272bfbbdf5d0023b5fb9bc6217c92bf068fa5a99820f5/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3710a9751938947e6327ea9f3ea6332a09bf0ba0c09cae9cb1f250bd1f1549bc", size = 142585 },
+    { url = "https://files.pythonhosted.org/packages/3b/a0/a68980ab8a1f45a36d9745d35049c1af57d27255eff8c907e3add84cf68f/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:82357d85de703176b5587dbe6ade8ff67f9f69a41c0733cf2425378b49954de5", size = 144408 },
+    { url = "https://files.pythonhosted.org/packages/d7/a1/493919799446464ed0299c8eef3c3fad0daf1c3cd48bff9263c731b0d9e2/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:47334db71978b23ebcf3c0f9f5ee98b8d65992b65c9c4f2d34c2eaf5bcaf0594", size = 139076 },
+    { url = "https://files.pythonhosted.org/packages/fb/9d/9c13753a5a6e0db4a0a6edb1cef7aee39859177b64e1a1e748a6e3ba62c2/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:8ce7fd6767a1cc5a92a639b391891bf1c268b03ec7e021c7d6d902285259685c", size = 146874 },
+    { url = "https://files.pythonhosted.org/packages/75/d2/0ab54463d3410709c09266dfb416d032a08f97fd7d60e94b8c6ef54ae14b/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:f1a2f519ae173b5b6a2c9d5fa3116ce16e48b3462c8b96dfdded11055e3d6365", size = 150871 },
+    { url = "https://files.pythonhosted.org/packages/8d/c9/27e41d481557be53d51e60750b85aa40eaf52b841946b3cdeff363105737/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:63bc5c4ae26e4bc6be6469943b8253c0fd4e4186c43ad46e713ea61a0ba49129", size = 148546 },
+    { url = "https://files.pythonhosted.org/packages/ee/44/4f62042ca8cdc0cabf87c0fc00ae27cd8b53ab68be3605ba6d071f742ad3/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:bcb4f8ea87d03bc51ad04add8ceaf9b0f085ac045ab4d74e73bbc2dc033f0236", size = 143048 },
+    { url = "https://files.pythonhosted.org/packages/01/f8/38842422988b795220eb8038745d27a675ce066e2ada79516c118f291f07/charset_normalizer-3.4.0-cp311-cp311-win32.whl", hash = "sha256:9ae4ef0b3f6b41bad6366fb0ea4fc1d7ed051528e113a60fa2a65a9abb5b1d99", size = 94389 },
+    { url = "https://files.pythonhosted.org/packages/0b/6e/b13bd47fa9023b3699e94abf565b5a2f0b0be6e9ddac9812182596ee62e4/charset_normalizer-3.4.0-cp311-cp311-win_amd64.whl", hash = "sha256:cee4373f4d3ad28f1ab6290684d8e2ebdb9e7a1b74fdc39e4c211995f77bec27", size = 101752 },
+    { url = "https://files.pythonhosted.org/packages/d3/0b/4b7a70987abf9b8196845806198975b6aab4ce016632f817ad758a5aa056/charset_normalizer-3.4.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0713f3adb9d03d49d365b70b84775d0a0d18e4ab08d12bc46baa6132ba78aaf6", size = 194445 },
+    { url = "https://files.pythonhosted.org/packages/50/89/354cc56cf4dd2449715bc9a0f54f3aef3dc700d2d62d1fa5bbea53b13426/charset_normalizer-3.4.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:de7376c29d95d6719048c194a9cf1a1b0393fbe8488a22008610b0361d834ecf", size = 125275 },
+    { url = "https://files.pythonhosted.org/packages/fa/44/b730e2a2580110ced837ac083d8ad222343c96bb6b66e9e4e706e4d0b6df/charset_normalizer-3.4.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4a51b48f42d9358460b78725283f04bddaf44a9358197b889657deba38f329db", size = 119020 },
+    { url = "https://files.pythonhosted.org/packages/9d/e4/9263b8240ed9472a2ae7ddc3e516e71ef46617fe40eaa51221ccd4ad9a27/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b295729485b06c1a0683af02a9e42d2caa9db04a373dc38a6a58cdd1e8abddf1", size = 139128 },
+    { url = "https://files.pythonhosted.org/packages/6b/e3/9f73e779315a54334240353eaea75854a9a690f3f580e4bd85d977cb2204/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ee803480535c44e7f5ad00788526da7d85525cfefaf8acf8ab9a310000be4b03", size = 149277 },
+    { url = "https://files.pythonhosted.org/packages/1a/cf/f1f50c2f295312edb8a548d3fa56a5c923b146cd3f24114d5adb7e7be558/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3d59d125ffbd6d552765510e3f31ed75ebac2c7470c7274195b9161a32350284", size = 142174 },
+    { url = "https://files.pythonhosted.org/packages/16/92/92a76dc2ff3a12e69ba94e7e05168d37d0345fa08c87e1fe24d0c2a42223/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8cda06946eac330cbe6598f77bb54e690b4ca93f593dee1568ad22b04f347c15", size = 143838 },
+    { url = "https://files.pythonhosted.org/packages/a4/01/2117ff2b1dfc61695daf2babe4a874bca328489afa85952440b59819e9d7/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:07afec21bbbbf8a5cc3651aa96b980afe2526e7f048fdfb7f1014d84acc8b6d8", size = 146149 },
+    { url = "https://files.pythonhosted.org/packages/f6/9b/93a332b8d25b347f6839ca0a61b7f0287b0930216994e8bf67a75d050255/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6b40e8d38afe634559e398cc32b1472f376a4099c75fe6299ae607e404c033b2", size = 140043 },
+    { url = "https://files.pythonhosted.org/packages/ab/f6/7ac4a01adcdecbc7a7587767c776d53d369b8b971382b91211489535acf0/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:b8dcd239c743aa2f9c22ce674a145e0a25cb1566c495928440a181ca1ccf6719", size = 148229 },
+    { url = "https://files.pythonhosted.org/packages/9d/be/5708ad18161dee7dc6a0f7e6cf3a88ea6279c3e8484844c0590e50e803ef/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:84450ba661fb96e9fd67629b93d2941c871ca86fc38d835d19d4225ff946a631", size = 151556 },
+    { url = "https://files.pythonhosted.org/packages/5a/bb/3d8bc22bacb9eb89785e83e6723f9888265f3a0de3b9ce724d66bd49884e/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:44aeb140295a2f0659e113b31cfe92c9061622cadbc9e2a2f7b8ef6b1e29ef4b", size = 149772 },
+    { url = "https://files.pythonhosted.org/packages/f7/fa/d3fc622de05a86f30beea5fc4e9ac46aead4731e73fd9055496732bcc0a4/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1db4e7fefefd0f548d73e2e2e041f9df5c59e178b4c72fbac4cc6f535cfb1565", size = 144800 },
+    { url = "https://files.pythonhosted.org/packages/9a/65/bdb9bc496d7d190d725e96816e20e2ae3a6fa42a5cac99c3c3d6ff884118/charset_normalizer-3.4.0-cp312-cp312-win32.whl", hash = "sha256:5726cf76c982532c1863fb64d8c6dd0e4c90b6ece9feb06c9f202417a31f7dd7", size = 94836 },
+    { url = "https://files.pythonhosted.org/packages/3e/67/7b72b69d25b89c0b3cea583ee372c43aa24df15f0e0f8d3982c57804984b/charset_normalizer-3.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:b197e7094f232959f8f20541ead1d9862ac5ebea1d58e9849c1bf979255dfac9", size = 102187 },
+    { url = "https://files.pythonhosted.org/packages/f3/89/68a4c86f1a0002810a27f12e9a7b22feb198c59b2f05231349fbce5c06f4/charset_normalizer-3.4.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:dd4eda173a9fcccb5f2e2bd2a9f423d180194b1bf17cf59e3269899235b2a114", size = 194617 },
+    { url = "https://files.pythonhosted.org/packages/4f/cd/8947fe425e2ab0aa57aceb7807af13a0e4162cd21eee42ef5b053447edf5/charset_normalizer-3.4.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e9e3c4c9e1ed40ea53acf11e2a386383c3304212c965773704e4603d589343ed", size = 125310 },
+    { url = "https://files.pythonhosted.org/packages/5b/f0/b5263e8668a4ee9becc2b451ed909e9c27058337fda5b8c49588183c267a/charset_normalizer-3.4.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:92a7e36b000bf022ef3dbb9c46bfe2d52c047d5e3f3343f43204263c5addc250", size = 119126 },
+    { url = "https://files.pythonhosted.org/packages/ff/6e/e445afe4f7fda27a533f3234b627b3e515a1b9429bc981c9a5e2aa5d97b6/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:54b6a92d009cbe2fb11054ba694bc9e284dad30a26757b1e372a1fdddaf21920", size = 139342 },
+    { url = "https://files.pythonhosted.org/packages/a1/b2/4af9993b532d93270538ad4926c8e37dc29f2111c36f9c629840c57cd9b3/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1ffd9493de4c922f2a38c2bf62b831dcec90ac673ed1ca182fe11b4d8e9f2a64", size = 149383 },
+    { url = "https://files.pythonhosted.org/packages/fb/6f/4e78c3b97686b871db9be6f31d64e9264e889f8c9d7ab33c771f847f79b7/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:35c404d74c2926d0287fbd63ed5d27eb911eb9e4a3bb2c6d294f3cfd4a9e0c23", size = 142214 },
+    { url = "https://files.pythonhosted.org/packages/2b/c9/1c8fe3ce05d30c87eff498592c89015b19fade13df42850aafae09e94f35/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4796efc4faf6b53a18e3d46343535caed491776a22af773f366534056c4e1fbc", size = 144104 },
+    { url = "https://files.pythonhosted.org/packages/ee/68/efad5dcb306bf37db7db338338e7bb8ebd8cf38ee5bbd5ceaaaa46f257e6/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e7fdd52961feb4c96507aa649550ec2a0d527c086d284749b2f582f2d40a2e0d", size = 146255 },
+    { url = "https://files.pythonhosted.org/packages/0c/75/1ed813c3ffd200b1f3e71121c95da3f79e6d2a96120163443b3ad1057505/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:92db3c28b5b2a273346bebb24857fda45601aef6ae1c011c0a997106581e8a88", size = 140251 },
+    { url = "https://files.pythonhosted.org/packages/7d/0d/6f32255c1979653b448d3c709583557a4d24ff97ac4f3a5be156b2e6a210/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ab973df98fc99ab39080bfb0eb3a925181454d7c3ac8a1e695fddfae696d9e90", size = 148474 },
+    { url = "https://files.pythonhosted.org/packages/ac/a0/c1b5298de4670d997101fef95b97ac440e8c8d8b4efa5a4d1ef44af82f0d/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:4b67fdab07fdd3c10bb21edab3cbfe8cf5696f453afce75d815d9d7223fbe88b", size = 151849 },
+    { url = "https://files.pythonhosted.org/packages/04/4f/b3961ba0c664989ba63e30595a3ed0875d6790ff26671e2aae2fdc28a399/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:aa41e526a5d4a9dfcfbab0716c7e8a1b215abd3f3df5a45cf18a12721d31cb5d", size = 149781 },
+    { url = "https://files.pythonhosted.org/packages/d8/90/6af4cd042066a4adad58ae25648a12c09c879efa4849c705719ba1b23d8c/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ffc519621dce0c767e96b9c53f09c5d215578e10b02c285809f76509a3931482", size = 144970 },
+    { url = "https://files.pythonhosted.org/packages/cc/67/e5e7e0cbfefc4ca79025238b43cdf8a2037854195b37d6417f3d0895c4c2/charset_normalizer-3.4.0-cp313-cp313-win32.whl", hash = "sha256:f19c1585933c82098c2a520f8ec1227f20e339e33aca8fa6f956f6691b784e67", size = 94973 },
+    { url = "https://files.pythonhosted.org/packages/65/97/fc9bbc54ee13d33dc54a7fcf17b26368b18505500fc01e228c27b5222d80/charset_normalizer-3.4.0-cp313-cp313-win_amd64.whl", hash = "sha256:707b82d19e65c9bd28b81dde95249b07bf9f5b90ebe1ef17d9b57473f8a64b7b", size = 102308 },
+    { url = "https://files.pythonhosted.org/packages/bf/9b/08c0432272d77b04803958a4598a51e2a4b51c06640af8b8f0f908c18bf2/charset_normalizer-3.4.0-py3-none-any.whl", hash = "sha256:fe9f97feb71aa9896b81973a7bbada8c49501dc73e58a10fcef6663af95e5079", size = 49446 },
+]
+
+[[package]]
+name = "deprecated"
+version = "1.2.15"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "wrapt" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/2e/a3/53e7d78a6850ffdd394d7048a31a6f14e44900adedf190f9a165f6b69439/deprecated-1.2.15.tar.gz", hash = "sha256:683e561a90de76239796e6b6feac66b99030d2dd3fcf61ef996330f14bbb9b0d", size = 2977612 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1d/8f/c7f227eb42cfeaddce3eb0c96c60cbca37797fa7b34f8e1aeadf6c5c0983/Deprecated-1.2.15-py2.py3-none-any.whl", hash = "sha256:353bc4a8ac4bfc96800ddab349d89c25dec1079f65fd53acdcc1e0b975b21320", size = 9941 },
+]
+
+[[package]]
+name = "fake-bpy-module-latest"
+version = "20240524"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c8/d9/f92ba292561805c06eb688ea8eb3c44a8c519bc6a092d040084582809e98/fake_bpy_module_latest-20240524.tar.gz", hash = "sha256:752da840cf6e69b1e8898382a89b2107a98dc6cb45287d44ac32be1176f09bed", size = 967498 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5a/16/c2cb7912fd1ccc13a57ab43587ab4c97e3227ed15b7f890431031e31a1bd/fake_bpy_module_latest-20240524-py3-none-any.whl", hash = "sha256:909756548ac8d6fcdc647082442d0c544f872c55d9884ec85301d69e79837688", size = 1200494 },
+]
+
+[[package]]
+name = "gql"
+version = "3.5.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "backoff" },
+    { name = "graphql-core" },
+    { name = "yarl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3d/85/feda24b33adcc6c8463a62a8e2ca2cc3425dc6d687388ff728ceae231204/gql-3.5.0.tar.gz", hash = "sha256:ccb9c5db543682b28f577069950488218ed65d4ac70bb03b6929aaadaf636de9", size = 179939 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/74/fb/01a200e1c31b79690427c8e983014e4220d2652b4372a46fe4598e1d7a8e/gql-3.5.0-py2.py3-none-any.whl", hash = "sha256:70dda5694a5b194a8441f077aa5fb70cc94e4ec08016117523f013680901ecb7", size = 74001 },
+]
+
+[package.optional-dependencies]
+requests = [
+    { name = "requests" },
+    { name = "requests-toolbelt" },
+]
+websockets = [
+    { name = "websockets" },
+]
+
+[[package]]
+name = "graphql-core"
+version = "3.2.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/2e/b5/ebc6fe3852e2d2fdaf682dddfc366934f3d2c9ef9b6d1b0e6ca348d936ba/graphql_core-3.2.5.tar.gz", hash = "sha256:e671b90ed653c808715645e3998b7ab67d382d55467b7e2978549111bbabf8d5", size = 504664 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e3/dc/078bd6b304de790618ebb95e2aedaadb78f4527ac43a9ad8815f006636b6/graphql_core-3.2.5-py3-none-any.whl", hash = "sha256:2f150d5096448aa4f8ab26268567bbfeef823769893b39c1a2e1409590939c8a", size = 203189 },
+]
+
+[[package]]
+name = "h11"
+version = "0.14.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f5/38/3af3d3633a34a3316095b39c8e8fb4853a28a536e55d347bd8d8e9a14b03/h11-0.14.0.tar.gz", hash = "sha256:8f19fbbe99e72420ff35c00b27a34cb9937e902a8b810e2c88300c6f0a3b699d", size = 100418 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/95/04/ff642e65ad6b90db43e668d70ffb6736436c7ce41fcc549f4e9472234127/h11-0.14.0-py3-none-any.whl", hash = "sha256:e3fe4ac4b851c468cc8363d500db52c2ead036020723024a109d37346efaa761", size = 58259 },
+]
+
+[[package]]
+name = "httpcore"
+version = "1.0.7"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/6a/41/d7d0a89eb493922c37d343b607bc1b5da7f5be7e383740b4753ad8943e90/httpcore-1.0.7.tar.gz", hash = "sha256:8551cb62a169ec7162ac7be8d4817d561f60e08eaa485234898414bb5a8a0b4c", size = 85196 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/87/f5/72347bc88306acb359581ac4d52f23c0ef445b57157adedb9aee0cd689d2/httpcore-1.0.7-py3-none-any.whl", hash = "sha256:a3fff8f43dc260d5bd363d9f9cf1830fa3a458b332856f34282de498ed420edd", size = 78551 },
+]
+
+[[package]]
+name = "httpx"
+version = "0.28.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "certifi" },
+    { name = "httpcore" },
+    { name = "idna" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517 },
+]
+
+[[package]]
+name = "idna"
+version = "3.10"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f1/70/7703c29685631f5a7590aa73f1f1d3fa9a380e654b86af429e0934a32f7d/idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9", size = 190490 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", size = 70442 },
+]
+
+[[package]]
+name = "multidict"
+version = "6.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d6/be/504b89a5e9ca731cd47487e91c469064f8ae5af93b7259758dcfc2b9c848/multidict-6.1.0.tar.gz", hash = "sha256:22ae2ebf9b0c69d206c003e2f6a914ea33f0a932d4aa16f236afc049d9958f4a", size = 64002 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/93/13/df3505a46d0cd08428e4c8169a196131d1b0c4b515c3649829258843dde6/multidict-6.1.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:3efe2c2cb5763f2f1b275ad2bf7a287d3f7ebbef35648a9726e3b69284a4f3d6", size = 48570 },
+    { url = "https://files.pythonhosted.org/packages/f0/e1/a215908bfae1343cdb72f805366592bdd60487b4232d039c437fe8f5013d/multidict-6.1.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c7053d3b0353a8b9de430a4f4b4268ac9a4fb3481af37dfe49825bf45ca24156", size = 29316 },
+    { url = "https://files.pythonhosted.org/packages/70/0f/6dc70ddf5d442702ed74f298d69977f904960b82368532c88e854b79f72b/multidict-6.1.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:27e5fc84ccef8dfaabb09d82b7d179c7cf1a3fbc8a966f8274fcb4ab2eb4cadb", size = 29640 },
+    { url = "https://files.pythonhosted.org/packages/d8/6d/9c87b73a13d1cdea30b321ef4b3824449866bd7f7127eceed066ccb9b9ff/multidict-6.1.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0e2b90b43e696f25c62656389d32236e049568b39320e2735d51f08fd362761b", size = 131067 },
+    { url = "https://files.pythonhosted.org/packages/cc/1e/1b34154fef373371fd6c65125b3d42ff5f56c7ccc6bfff91b9b3c60ae9e0/multidict-6.1.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d83a047959d38a7ff552ff94be767b7fd79b831ad1cd9920662db05fec24fe72", size = 138507 },
+    { url = "https://files.pythonhosted.org/packages/fb/e0/0bc6b2bac6e461822b5f575eae85da6aae76d0e2a79b6665d6206b8e2e48/multidict-6.1.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d1a9dd711d0877a1ece3d2e4fea11a8e75741ca21954c919406b44e7cf971304", size = 133905 },
+    { url = "https://files.pythonhosted.org/packages/ba/af/73d13b918071ff9b2205fcf773d316e0f8fefb4ec65354bbcf0b10908cc6/multidict-6.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ec2abea24d98246b94913b76a125e855eb5c434f7c46546046372fe60f666351", size = 129004 },
+    { url = "https://files.pythonhosted.org/packages/74/21/23960627b00ed39643302d81bcda44c9444ebcdc04ee5bedd0757513f259/multidict-6.1.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4867cafcbc6585e4b678876c489b9273b13e9fff9f6d6d66add5e15d11d926cb", size = 121308 },
+    { url = "https://files.pythonhosted.org/packages/8b/5c/cf282263ffce4a596ed0bb2aa1a1dddfe1996d6a62d08842a8d4b33dca13/multidict-6.1.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:5b48204e8d955c47c55b72779802b219a39acc3ee3d0116d5080c388970b76e3", size = 132608 },
+    { url = "https://files.pythonhosted.org/packages/d7/3e/97e778c041c72063f42b290888daff008d3ab1427f5b09b714f5a8eff294/multidict-6.1.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:d8fff389528cad1618fb4b26b95550327495462cd745d879a8c7c2115248e399", size = 127029 },
+    { url = "https://files.pythonhosted.org/packages/47/ac/3efb7bfe2f3aefcf8d103e9a7162572f01936155ab2f7ebcc7c255a23212/multidict-6.1.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:a7a9541cd308eed5e30318430a9c74d2132e9a8cb46b901326272d780bf2d423", size = 137594 },
+    { url = "https://files.pythonhosted.org/packages/42/9b/6c6e9e8dc4f915fc90a9b7798c44a30773dea2995fdcb619870e705afe2b/multidict-6.1.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:da1758c76f50c39a2efd5e9859ce7d776317eb1dd34317c8152ac9251fc574a3", size = 134556 },
+    { url = "https://files.pythonhosted.org/packages/1d/10/8e881743b26aaf718379a14ac58572a240e8293a1c9d68e1418fb11c0f90/multidict-6.1.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:c943a53e9186688b45b323602298ab727d8865d8c9ee0b17f8d62d14b56f0753", size = 130993 },
+    { url = "https://files.pythonhosted.org/packages/45/84/3eb91b4b557442802d058a7579e864b329968c8d0ea57d907e7023c677f2/multidict-6.1.0-cp311-cp311-win32.whl", hash = "sha256:90f8717cb649eea3504091e640a1b8568faad18bd4b9fcd692853a04475a4b80", size = 26405 },
+    { url = "https://files.pythonhosted.org/packages/9f/0b/ad879847ecbf6d27e90a6eabb7eff6b62c129eefe617ea45eae7c1f0aead/multidict-6.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:82176036e65644a6cc5bd619f65f6f19781e8ec2e5330f51aa9ada7504cc1926", size = 28795 },
+    { url = "https://files.pythonhosted.org/packages/fd/16/92057c74ba3b96d5e211b553895cd6dc7cc4d1e43d9ab8fafc727681ef71/multidict-6.1.0-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:b04772ed465fa3cc947db808fa306d79b43e896beb677a56fb2347ca1a49c1fa", size = 48713 },
+    { url = "https://files.pythonhosted.org/packages/94/3d/37d1b8893ae79716179540b89fc6a0ee56b4a65fcc0d63535c6f5d96f217/multidict-6.1.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:6180c0ae073bddeb5a97a38c03f30c233e0a4d39cd86166251617d1bbd0af436", size = 29516 },
+    { url = "https://files.pythonhosted.org/packages/a2/12/adb6b3200c363062f805275b4c1e656be2b3681aada66c80129932ff0bae/multidict-6.1.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:071120490b47aa997cca00666923a83f02c7fbb44f71cf7f136df753f7fa8761", size = 29557 },
+    { url = "https://files.pythonhosted.org/packages/47/e9/604bb05e6e5bce1e6a5cf80a474e0f072e80d8ac105f1b994a53e0b28c42/multidict-6.1.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:50b3a2710631848991d0bf7de077502e8994c804bb805aeb2925a981de58ec2e", size = 130170 },
+    { url = "https://files.pythonhosted.org/packages/7e/13/9efa50801785eccbf7086b3c83b71a4fb501a4d43549c2f2f80b8787d69f/multidict-6.1.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b58c621844d55e71c1b7f7c498ce5aa6985d743a1a59034c57a905b3f153c1ef", size = 134836 },
+    { url = "https://files.pythonhosted.org/packages/bf/0f/93808b765192780d117814a6dfcc2e75de6dcc610009ad408b8814dca3ba/multidict-6.1.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:55b6d90641869892caa9ca42ff913f7ff1c5ece06474fbd32fb2cf6834726c95", size = 133475 },
+    { url = "https://files.pythonhosted.org/packages/d3/c8/529101d7176fe7dfe1d99604e48d69c5dfdcadb4f06561f465c8ef12b4df/multidict-6.1.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4b820514bfc0b98a30e3d85462084779900347e4d49267f747ff54060cc33925", size = 131049 },
+    { url = "https://files.pythonhosted.org/packages/ca/0c/fc85b439014d5a58063e19c3a158a889deec399d47b5269a0f3b6a2e28bc/multidict-6.1.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:10a9b09aba0c5b48c53761b7c720aaaf7cf236d5fe394cd399c7ba662d5f9966", size = 120370 },
+    { url = "https://files.pythonhosted.org/packages/db/46/d4416eb20176492d2258fbd47b4abe729ff3b6e9c829ea4236f93c865089/multidict-6.1.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1e16bf3e5fc9f44632affb159d30a437bfe286ce9e02754759be5536b169b305", size = 125178 },
+    { url = "https://files.pythonhosted.org/packages/5b/46/73697ad7ec521df7de5531a32780bbfd908ded0643cbe457f981a701457c/multidict-6.1.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:76f364861c3bfc98cbbcbd402d83454ed9e01a5224bb3a28bf70002a230f73e2", size = 119567 },
+    { url = "https://files.pythonhosted.org/packages/cd/ed/51f060e2cb0e7635329fa6ff930aa5cffa17f4c7f5c6c3ddc3500708e2f2/multidict-6.1.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:820c661588bd01a0aa62a1283f20d2be4281b086f80dad9e955e690c75fb54a2", size = 129822 },
+    { url = "https://files.pythonhosted.org/packages/df/9e/ee7d1954b1331da3eddea0c4e08d9142da5f14b1321c7301f5014f49d492/multidict-6.1.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:0e5f362e895bc5b9e67fe6e4ded2492d8124bdf817827f33c5b46c2fe3ffaca6", size = 128656 },
+    { url = "https://files.pythonhosted.org/packages/77/00/8538f11e3356b5d95fa4b024aa566cde7a38aa7a5f08f4912b32a037c5dc/multidict-6.1.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3ec660d19bbc671e3a6443325f07263be452c453ac9e512f5eb935e7d4ac28b3", size = 125360 },
+    { url = "https://files.pythonhosted.org/packages/be/05/5d334c1f2462d43fec2363cd00b1c44c93a78c3925d952e9a71caf662e96/multidict-6.1.0-cp312-cp312-win32.whl", hash = "sha256:58130ecf8f7b8112cdb841486404f1282b9c86ccb30d3519faf301b2e5659133", size = 26382 },
+    { url = "https://files.pythonhosted.org/packages/a3/bf/f332a13486b1ed0496d624bcc7e8357bb8053823e8cd4b9a18edc1d97e73/multidict-6.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:188215fc0aafb8e03341995e7c4797860181562380f81ed0a87ff455b70bf1f1", size = 28529 },
+    { url = "https://files.pythonhosted.org/packages/22/67/1c7c0f39fe069aa4e5d794f323be24bf4d33d62d2a348acdb7991f8f30db/multidict-6.1.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:d569388c381b24671589335a3be6e1d45546c2988c2ebe30fdcada8457a31008", size = 48771 },
+    { url = "https://files.pythonhosted.org/packages/3c/25/c186ee7b212bdf0df2519eacfb1981a017bda34392c67542c274651daf23/multidict-6.1.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:052e10d2d37810b99cc170b785945421141bf7bb7d2f8799d431e7db229c385f", size = 29533 },
+    { url = "https://files.pythonhosted.org/packages/67/5e/04575fd837e0958e324ca035b339cea174554f6f641d3fb2b4f2e7ff44a2/multidict-6.1.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f90c822a402cb865e396a504f9fc8173ef34212a342d92e362ca498cad308e28", size = 29595 },
+    { url = "https://files.pythonhosted.org/packages/d3/b2/e56388f86663810c07cfe4a3c3d87227f3811eeb2d08450b9e5d19d78876/multidict-6.1.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b225d95519a5bf73860323e633a664b0d85ad3d5bede6d30d95b35d4dfe8805b", size = 130094 },
+    { url = "https://files.pythonhosted.org/packages/6c/ee/30ae9b4186a644d284543d55d491fbd4239b015d36b23fea43b4c94f7052/multidict-6.1.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:23bfd518810af7de1116313ebd9092cb9aa629beb12f6ed631ad53356ed6b86c", size = 134876 },
+    { url = "https://files.pythonhosted.org/packages/84/c7/70461c13ba8ce3c779503c70ec9d0345ae84de04521c1f45a04d5f48943d/multidict-6.1.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5c09fcfdccdd0b57867577b719c69e347a436b86cd83747f179dbf0cc0d4c1f3", size = 133500 },
+    { url = "https://files.pythonhosted.org/packages/4a/9f/002af221253f10f99959561123fae676148dd730e2daa2cd053846a58507/multidict-6.1.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bf6bea52ec97e95560af5ae576bdac3aa3aae0b6758c6efa115236d9e07dae44", size = 131099 },
+    { url = "https://files.pythonhosted.org/packages/82/42/d1c7a7301d52af79d88548a97e297f9d99c961ad76bbe6f67442bb77f097/multidict-6.1.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:57feec87371dbb3520da6192213c7d6fc892d5589a93db548331954de8248fd2", size = 120403 },
+    { url = "https://files.pythonhosted.org/packages/68/f3/471985c2c7ac707547553e8f37cff5158030d36bdec4414cb825fbaa5327/multidict-6.1.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:0c3f390dc53279cbc8ba976e5f8035eab997829066756d811616b652b00a23a3", size = 125348 },
+    { url = "https://files.pythonhosted.org/packages/67/2c/e6df05c77e0e433c214ec1d21ddd203d9a4770a1f2866a8ca40a545869a0/multidict-6.1.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:59bfeae4b25ec05b34f1956eaa1cb38032282cd4dfabc5056d0a1ec4d696d3aa", size = 119673 },
+    { url = "https://files.pythonhosted.org/packages/c5/cd/bc8608fff06239c9fb333f9db7743a1b2eafe98c2666c9a196e867a3a0a4/multidict-6.1.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:b2f59caeaf7632cc633b5cf6fc449372b83bbdf0da4ae04d5be36118e46cc0aa", size = 129927 },
+    { url = "https://files.pythonhosted.org/packages/44/8e/281b69b7bc84fc963a44dc6e0bbcc7150e517b91df368a27834299a526ac/multidict-6.1.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:37bb93b2178e02b7b618893990941900fd25b6b9ac0fa49931a40aecdf083fe4", size = 128711 },
+    { url = "https://files.pythonhosted.org/packages/12/a4/63e7cd38ed29dd9f1881d5119f272c898ca92536cdb53ffe0843197f6c85/multidict-6.1.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4e9f48f58c2c523d5a06faea47866cd35b32655c46b443f163d08c6d0ddb17d6", size = 125519 },
+    { url = "https://files.pythonhosted.org/packages/38/e0/4f5855037a72cd8a7a2f60a3952d9aa45feedb37ae7831642102604e8a37/multidict-6.1.0-cp313-cp313-win32.whl", hash = "sha256:3a37ffb35399029b45c6cc33640a92bef403c9fd388acce75cdc88f58bd19a81", size = 26426 },
+    { url = "https://files.pythonhosted.org/packages/7e/a5/17ee3a4db1e310b7405f5d25834460073a8ccd86198ce044dfaf69eac073/multidict-6.1.0-cp313-cp313-win_amd64.whl", hash = "sha256:e9aa71e15d9d9beaad2c6b9319edcdc0a49a43ef5c0a4c8265ca9ee7d6c67774", size = 28531 },
+    { url = "https://files.pythonhosted.org/packages/99/b7/b9e70fde2c0f0c9af4cc5277782a89b66d35948ea3369ec9f598358c3ac5/multidict-6.1.0-py3-none-any.whl", hash = "sha256:48e171e52d1c4d33888e529b999e5900356b9ae588c2f09a52dcefb158b27506", size = 10051 },
+]
+
+[[package]]
+name = "propcache"
+version = "0.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a9/4d/5e5a60b78dbc1d464f8a7bbaeb30957257afdc8512cbb9dfd5659304f5cd/propcache-0.2.0.tar.gz", hash = "sha256:df81779732feb9d01e5d513fad0122efb3d53bbc75f61b2a4f29a020bc985e70", size = 40951 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e0/1c/71eec730e12aec6511e702ad0cd73c2872eccb7cad39de8ba3ba9de693ef/propcache-0.2.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:63f13bf09cc3336eb04a837490b8f332e0db41da66995c9fd1ba04552e516354", size = 80811 },
+    { url = "https://files.pythonhosted.org/packages/89/c3/7e94009f9a4934c48a371632197406a8860b9f08e3f7f7d922ab69e57a41/propcache-0.2.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:608cce1da6f2672a56b24a015b42db4ac612ee709f3d29f27a00c943d9e851de", size = 46365 },
+    { url = "https://files.pythonhosted.org/packages/c0/1d/c700d16d1d6903aeab28372fe9999762f074b80b96a0ccc953175b858743/propcache-0.2.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:466c219deee4536fbc83c08d09115249db301550625c7fef1c5563a584c9bc87", size = 45602 },
+    { url = "https://files.pythonhosted.org/packages/2e/5e/4a3e96380805bf742712e39a4534689f4cddf5fa2d3a93f22e9fd8001b23/propcache-0.2.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fc2db02409338bf36590aa985a461b2c96fce91f8e7e0f14c50c5fcc4f229016", size = 236161 },
+    { url = "https://files.pythonhosted.org/packages/a5/85/90132481183d1436dff6e29f4fa81b891afb6cb89a7306f32ac500a25932/propcache-0.2.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a6ed8db0a556343d566a5c124ee483ae113acc9a557a807d439bcecc44e7dfbb", size = 244938 },
+    { url = "https://files.pythonhosted.org/packages/4a/89/c893533cb45c79c970834274e2d0f6d64383ec740be631b6a0a1d2b4ddc0/propcache-0.2.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:91997d9cb4a325b60d4e3f20967f8eb08dfcb32b22554d5ef78e6fd1dda743a2", size = 243576 },
+    { url = "https://files.pythonhosted.org/packages/8c/56/98c2054c8526331a05f205bf45cbb2cda4e58e56df70e76d6a509e5d6ec6/propcache-0.2.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4c7dde9e533c0a49d802b4f3f218fa9ad0a1ce21f2c2eb80d5216565202acab4", size = 236011 },
+    { url = "https://files.pythonhosted.org/packages/2d/0c/8b8b9f8a6e1abd869c0fa79b907228e7abb966919047d294ef5df0d136cf/propcache-0.2.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ffcad6c564fe6b9b8916c1aefbb37a362deebf9394bd2974e9d84232e3e08504", size = 224834 },
+    { url = "https://files.pythonhosted.org/packages/18/bb/397d05a7298b7711b90e13108db697732325cafdcd8484c894885c1bf109/propcache-0.2.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:97a58a28bcf63284e8b4d7b460cbee1edaab24634e82059c7b8c09e65284f178", size = 224946 },
+    { url = "https://files.pythonhosted.org/packages/25/19/4fc08dac19297ac58135c03770b42377be211622fd0147f015f78d47cd31/propcache-0.2.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:945db8ee295d3af9dbdbb698cce9bbc5c59b5c3fe328bbc4387f59a8a35f998d", size = 217280 },
+    { url = "https://files.pythonhosted.org/packages/7e/76/c79276a43df2096ce2aba07ce47576832b1174c0c480fe6b04bd70120e59/propcache-0.2.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:39e104da444a34830751715f45ef9fc537475ba21b7f1f5b0f4d71a3b60d7fe2", size = 220088 },
+    { url = "https://files.pythonhosted.org/packages/c3/9a/8a8cf428a91b1336b883f09c8b884e1734c87f724d74b917129a24fe2093/propcache-0.2.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:c5ecca8f9bab618340c8e848d340baf68bcd8ad90a8ecd7a4524a81c1764b3db", size = 233008 },
+    { url = "https://files.pythonhosted.org/packages/25/7b/768a8969abd447d5f0f3333df85c6a5d94982a1bc9a89c53c154bf7a8b11/propcache-0.2.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:c436130cc779806bdf5d5fae0d848713105472b8566b75ff70048c47d3961c5b", size = 237719 },
+    { url = "https://files.pythonhosted.org/packages/ed/0d/e5d68ccc7976ef8b57d80613ac07bbaf0614d43f4750cf953f0168ef114f/propcache-0.2.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:191db28dc6dcd29d1a3e063c3be0b40688ed76434622c53a284e5427565bbd9b", size = 227729 },
+    { url = "https://files.pythonhosted.org/packages/05/64/17eb2796e2d1c3d0c431dc5f40078d7282f4645af0bb4da9097fbb628c6c/propcache-0.2.0-cp311-cp311-win32.whl", hash = "sha256:5f2564ec89058ee7c7989a7b719115bdfe2a2fb8e7a4543b8d1c0cc4cf6478c1", size = 40473 },
+    { url = "https://files.pythonhosted.org/packages/83/c5/e89fc428ccdc897ade08cd7605f174c69390147526627a7650fb883e0cd0/propcache-0.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:6e2e54267980349b723cff366d1e29b138b9a60fa376664a157a342689553f71", size = 44921 },
+    { url = "https://files.pythonhosted.org/packages/7c/46/a41ca1097769fc548fc9216ec4c1471b772cc39720eb47ed7e38ef0006a9/propcache-0.2.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:2ee7606193fb267be4b2e3b32714f2d58cad27217638db98a60f9efb5efeccc2", size = 80800 },
+    { url = "https://files.pythonhosted.org/packages/75/4f/93df46aab9cc473498ff56be39b5f6ee1e33529223d7a4d8c0a6101a9ba2/propcache-0.2.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:91ee8fc02ca52e24bcb77b234f22afc03288e1dafbb1f88fe24db308910c4ac7", size = 46443 },
+    { url = "https://files.pythonhosted.org/packages/0b/17/308acc6aee65d0f9a8375e36c4807ac6605d1f38074b1581bd4042b9fb37/propcache-0.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2e900bad2a8456d00a113cad8c13343f3b1f327534e3589acc2219729237a2e8", size = 45676 },
+    { url = "https://files.pythonhosted.org/packages/65/44/626599d2854d6c1d4530b9a05e7ff2ee22b790358334b475ed7c89f7d625/propcache-0.2.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f52a68c21363c45297aca15561812d542f8fc683c85201df0bebe209e349f793", size = 246191 },
+    { url = "https://files.pythonhosted.org/packages/f2/df/5d996d7cb18df076debae7d76ac3da085c0575a9f2be6b1f707fe227b54c/propcache-0.2.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1e41d67757ff4fbc8ef2af99b338bfb955010444b92929e9e55a6d4dcc3c4f09", size = 251791 },
+    { url = "https://files.pythonhosted.org/packages/2e/6d/9f91e5dde8b1f662f6dd4dff36098ed22a1ef4e08e1316f05f4758f1576c/propcache-0.2.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a64e32f8bd94c105cc27f42d3b658902b5bcc947ece3c8fe7bc1b05982f60e89", size = 253434 },
+    { url = "https://files.pythonhosted.org/packages/3c/e9/1b54b7e26f50b3e0497cd13d3483d781d284452c2c50dd2a615a92a087a3/propcache-0.2.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:55346705687dbd7ef0d77883ab4f6fabc48232f587925bdaf95219bae072491e", size = 248150 },
+    { url = "https://files.pythonhosted.org/packages/a7/ef/a35bf191c8038fe3ce9a414b907371c81d102384eda5dbafe6f4dce0cf9b/propcache-0.2.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:00181262b17e517df2cd85656fcd6b4e70946fe62cd625b9d74ac9977b64d8d9", size = 233568 },
+    { url = "https://files.pythonhosted.org/packages/97/d9/d00bb9277a9165a5e6d60f2142cd1a38a750045c9c12e47ae087f686d781/propcache-0.2.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6994984550eaf25dd7fc7bd1b700ff45c894149341725bb4edc67f0ffa94efa4", size = 229874 },
+    { url = "https://files.pythonhosted.org/packages/8e/78/c123cf22469bdc4b18efb78893e69c70a8b16de88e6160b69ca6bdd88b5d/propcache-0.2.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:56295eb1e5f3aecd516d91b00cfd8bf3a13991de5a479df9e27dd569ea23959c", size = 225857 },
+    { url = "https://files.pythonhosted.org/packages/31/1b/fd6b2f1f36d028820d35475be78859d8c89c8f091ad30e377ac49fd66359/propcache-0.2.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:439e76255daa0f8151d3cb325f6dd4a3e93043e6403e6491813bcaaaa8733887", size = 227604 },
+    { url = "https://files.pythonhosted.org/packages/99/36/b07be976edf77a07233ba712e53262937625af02154353171716894a86a6/propcache-0.2.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:f6475a1b2ecb310c98c28d271a30df74f9dd436ee46d09236a6b750a7599ce57", size = 238430 },
+    { url = "https://files.pythonhosted.org/packages/0d/64/5822f496c9010e3966e934a011ac08cac8734561842bc7c1f65586e0683c/propcache-0.2.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:3444cdba6628accf384e349014084b1cacd866fbb88433cd9d279d90a54e0b23", size = 244814 },
+    { url = "https://files.pythonhosted.org/packages/fd/bd/8657918a35d50b18a9e4d78a5df7b6c82a637a311ab20851eef4326305c1/propcache-0.2.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:4a9d9b4d0a9b38d1c391bb4ad24aa65f306c6f01b512e10a8a34a2dc5675d348", size = 235922 },
+    { url = "https://files.pythonhosted.org/packages/a8/6f/ec0095e1647b4727db945213a9f395b1103c442ef65e54c62e92a72a3f75/propcache-0.2.0-cp312-cp312-win32.whl", hash = "sha256:69d3a98eebae99a420d4b28756c8ce6ea5a29291baf2dc9ff9414b42676f61d5", size = 40177 },
+    { url = "https://files.pythonhosted.org/packages/20/a2/bd0896fdc4f4c1db46d9bc361c8c79a9bf08ccc08ba054a98e38e7ba1557/propcache-0.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:ad9c9b99b05f163109466638bd30ada1722abb01bbb85c739c50b6dc11f92dc3", size = 44446 },
+    { url = "https://files.pythonhosted.org/packages/a8/a7/5f37b69197d4f558bfef5b4bceaff7c43cc9b51adf5bd75e9081d7ea80e4/propcache-0.2.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ecddc221a077a8132cf7c747d5352a15ed763b674c0448d811f408bf803d9ad7", size = 78120 },
+    { url = "https://files.pythonhosted.org/packages/c8/cd/48ab2b30a6b353ecb95a244915f85756d74f815862eb2ecc7a518d565b48/propcache-0.2.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0e53cb83fdd61cbd67202735e6a6687a7b491c8742dfc39c9e01e80354956763", size = 45127 },
+    { url = "https://files.pythonhosted.org/packages/a5/ba/0a1ef94a3412aab057bd996ed5f0ac7458be5bf469e85c70fa9ceb43290b/propcache-0.2.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:92fe151145a990c22cbccf9ae15cae8ae9eddabfc949a219c9f667877e40853d", size = 44419 },
+    { url = "https://files.pythonhosted.org/packages/b4/6c/ca70bee4f22fa99eacd04f4d2f1699be9d13538ccf22b3169a61c60a27fa/propcache-0.2.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d6a21ef516d36909931a2967621eecb256018aeb11fc48656e3257e73e2e247a", size = 229611 },
+    { url = "https://files.pythonhosted.org/packages/19/70/47b872a263e8511ca33718d96a10c17d3c853aefadeb86dc26e8421184b9/propcache-0.2.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3f88a4095e913f98988f5b338c1d4d5d07dbb0b6bad19892fd447484e483ba6b", size = 234005 },
+    { url = "https://files.pythonhosted.org/packages/4f/be/3b0ab8c84a22e4a3224719099c1229ddfdd8a6a1558cf75cb55ee1e35c25/propcache-0.2.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5a5b3bb545ead161be780ee85a2b54fdf7092815995661947812dde94a40f6fb", size = 237270 },
+    { url = "https://files.pythonhosted.org/packages/04/d8/f071bb000d4b8f851d312c3c75701e586b3f643fe14a2e3409b1b9ab3936/propcache-0.2.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:67aeb72e0f482709991aa91345a831d0b707d16b0257e8ef88a2ad246a7280bf", size = 231877 },
+    { url = "https://files.pythonhosted.org/packages/93/e7/57a035a1359e542bbb0a7df95aad6b9871ebee6dce2840cb157a415bd1f3/propcache-0.2.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3c997f8c44ec9b9b0bcbf2d422cc00a1d9b9c681f56efa6ca149a941e5560da2", size = 217848 },
+    { url = "https://files.pythonhosted.org/packages/f0/93/d1dea40f112ec183398fb6c42fde340edd7bab202411c4aa1a8289f461b6/propcache-0.2.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:2a66df3d4992bc1d725b9aa803e8c5a66c010c65c741ad901e260ece77f58d2f", size = 216987 },
+    { url = "https://files.pythonhosted.org/packages/62/4c/877340871251145d3522c2b5d25c16a1690ad655fbab7bb9ece6b117e39f/propcache-0.2.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:3ebbcf2a07621f29638799828b8d8668c421bfb94c6cb04269130d8de4fb7136", size = 212451 },
+    { url = "https://files.pythonhosted.org/packages/7c/bb/a91b72efeeb42906ef58ccf0cdb87947b54d7475fee3c93425d732f16a61/propcache-0.2.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:1235c01ddaa80da8235741e80815ce381c5267f96cc49b1477fdcf8c047ef325", size = 212879 },
+    { url = "https://files.pythonhosted.org/packages/9b/7f/ee7fea8faac57b3ec5d91ff47470c6c5d40d7f15d0b1fccac806348fa59e/propcache-0.2.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:3947483a381259c06921612550867b37d22e1df6d6d7e8361264b6d037595f44", size = 222288 },
+    { url = "https://files.pythonhosted.org/packages/ff/d7/acd67901c43d2e6b20a7a973d9d5fd543c6e277af29b1eb0e1f7bd7ca7d2/propcache-0.2.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:d5bed7f9805cc29c780f3aee05de3262ee7ce1f47083cfe9f77471e9d6777e83", size = 228257 },
+    { url = "https://files.pythonhosted.org/packages/8d/6f/6272ecc7a8daad1d0754cfc6c8846076a8cb13f810005c79b15ce0ef0cf2/propcache-0.2.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e4a91d44379f45f5e540971d41e4626dacd7f01004826a18cb048e7da7e96544", size = 221075 },
+    { url = "https://files.pythonhosted.org/packages/7c/bd/c7a6a719a6b3dd8b3aeadb3675b5783983529e4a3185946aa444d3e078f6/propcache-0.2.0-cp313-cp313-win32.whl", hash = "sha256:f902804113e032e2cdf8c71015651c97af6418363bea8d78dc0911d56c335032", size = 39654 },
+    { url = "https://files.pythonhosted.org/packages/88/e7/0eef39eff84fa3e001b44de0bd41c7c0e3432e7648ffd3d64955910f002d/propcache-0.2.0-cp313-cp313-win_amd64.whl", hash = "sha256:8f188cfcc64fb1266f4684206c9de0e80f54622c3f22a910cbd200478aeae61e", size = 43705 },
+    { url = "https://files.pythonhosted.org/packages/3d/b6/e6d98278f2d49b22b4d033c9f792eda783b9ab2094b041f013fc69bcde87/propcache-0.2.0-py3-none-any.whl", hash = "sha256:2ccc28197af5313706511fab3a8b66dcd6da067a1331372c82ea1cb74285e036", size = 11603 },
+]
+
+[[package]]
+name = "pydantic"
+version = "2.10.6"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-types" },
+    { name = "pydantic-core" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b7/ae/d5220c5c52b158b1de7ca89fc5edb72f304a70a4c540c84c8844bf4008de/pydantic-2.10.6.tar.gz", hash = "sha256:ca5daa827cce33de7a42be142548b0096bf05a7e7b365aebfa5f8eeec7128236", size = 761681 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/3c/8cc1cc84deffa6e25d2d0c688ebb80635dfdbf1dbea3e30c541c8cf4d860/pydantic-2.10.6-py3-none-any.whl", hash = "sha256:427d664bf0b8a2b34ff5dd0f5a18df00591adcee7198fbd71981054cef37b584", size = 431696 },
+]
+
+[[package]]
+name = "pydantic-core"
+version = "2.27.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/fc/01/f3e5ac5e7c25833db5eb555f7b7ab24cd6f8c322d3a3ad2d67a952dc0abc/pydantic_core-2.27.2.tar.gz", hash = "sha256:eb026e5a4c1fee05726072337ff51d1efb6f59090b7da90d30ea58625b1ffb39", size = 413443 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c2/89/f3450af9d09d44eea1f2c369f49e8f181d742f28220f88cc4dfaae91ea6e/pydantic_core-2.27.2-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:8e10c99ef58cfdf2a66fc15d66b16c4a04f62bca39db589ae8cba08bc55331bc", size = 1893421 },
+    { url = "https://files.pythonhosted.org/packages/9e/e3/71fe85af2021f3f386da42d291412e5baf6ce7716bd7101ea49c810eda90/pydantic_core-2.27.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:26f32e0adf166a84d0cb63be85c562ca8a6fa8de28e5f0d92250c6b7e9e2aff7", size = 1814998 },
+    { url = "https://files.pythonhosted.org/packages/a6/3c/724039e0d848fd69dbf5806894e26479577316c6f0f112bacaf67aa889ac/pydantic_core-2.27.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8c19d1ea0673cd13cc2f872f6c9ab42acc4e4f492a7ca9d3795ce2b112dd7e15", size = 1826167 },
+    { url = "https://files.pythonhosted.org/packages/2b/5b/1b29e8c1fb5f3199a9a57c1452004ff39f494bbe9bdbe9a81e18172e40d3/pydantic_core-2.27.2-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5e68c4446fe0810e959cdff46ab0a41ce2f2c86d227d96dc3847af0ba7def306", size = 1865071 },
+    { url = "https://files.pythonhosted.org/packages/89/6c/3985203863d76bb7d7266e36970d7e3b6385148c18a68cc8915fd8c84d57/pydantic_core-2.27.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d9640b0059ff4f14d1f37321b94061c6db164fbe49b334b31643e0528d100d99", size = 2036244 },
+    { url = "https://files.pythonhosted.org/packages/0e/41/f15316858a246b5d723f7d7f599f79e37493b2e84bfc789e58d88c209f8a/pydantic_core-2.27.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:40d02e7d45c9f8af700f3452f329ead92da4c5f4317ca9b896de7ce7199ea459", size = 2737470 },
+    { url = "https://files.pythonhosted.org/packages/a8/7c/b860618c25678bbd6d1d99dbdfdf0510ccb50790099b963ff78a124b754f/pydantic_core-2.27.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1c1fd185014191700554795c99b347d64f2bb637966c4cfc16998a0ca700d048", size = 1992291 },
+    { url = "https://files.pythonhosted.org/packages/bf/73/42c3742a391eccbeab39f15213ecda3104ae8682ba3c0c28069fbcb8c10d/pydantic_core-2.27.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d81d2068e1c1228a565af076598f9e7451712700b673de8f502f0334f281387d", size = 1994613 },
+    { url = "https://files.pythonhosted.org/packages/94/7a/941e89096d1175d56f59340f3a8ebaf20762fef222c298ea96d36a6328c5/pydantic_core-2.27.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:1a4207639fb02ec2dbb76227d7c751a20b1a6b4bc52850568e52260cae64ca3b", size = 2002355 },
+    { url = "https://files.pythonhosted.org/packages/6e/95/2359937a73d49e336a5a19848713555605d4d8d6940c3ec6c6c0ca4dcf25/pydantic_core-2.27.2-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:3de3ce3c9ddc8bbd88f6e0e304dea0e66d843ec9de1b0042b0911c1663ffd474", size = 2126661 },
+    { url = "https://files.pythonhosted.org/packages/2b/4c/ca02b7bdb6012a1adef21a50625b14f43ed4d11f1fc237f9d7490aa5078c/pydantic_core-2.27.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:30c5f68ded0c36466acede341551106821043e9afaad516adfb6e8fa80a4e6a6", size = 2153261 },
+    { url = "https://files.pythonhosted.org/packages/72/9d/a241db83f973049a1092a079272ffe2e3e82e98561ef6214ab53fe53b1c7/pydantic_core-2.27.2-cp311-cp311-win32.whl", hash = "sha256:c70c26d2c99f78b125a3459f8afe1aed4d9687c24fd677c6a4436bc042e50d6c", size = 1812361 },
+    { url = "https://files.pythonhosted.org/packages/e8/ef/013f07248041b74abd48a385e2110aa3a9bbfef0fbd97d4e6d07d2f5b89a/pydantic_core-2.27.2-cp311-cp311-win_amd64.whl", hash = "sha256:08e125dbdc505fa69ca7d9c499639ab6407cfa909214d500897d02afb816e7cc", size = 1982484 },
+    { url = "https://files.pythonhosted.org/packages/10/1c/16b3a3e3398fd29dca77cea0a1d998d6bde3902fa2706985191e2313cc76/pydantic_core-2.27.2-cp311-cp311-win_arm64.whl", hash = "sha256:26f0d68d4b235a2bae0c3fc585c585b4ecc51382db0e3ba402a22cbc440915e4", size = 1867102 },
+    { url = "https://files.pythonhosted.org/packages/d6/74/51c8a5482ca447871c93e142d9d4a92ead74de6c8dc5e66733e22c9bba89/pydantic_core-2.27.2-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:9e0c8cfefa0ef83b4da9588448b6d8d2a2bf1a53c3f1ae5fca39eb3061e2f0b0", size = 1893127 },
+    { url = "https://files.pythonhosted.org/packages/d3/f3/c97e80721735868313c58b89d2de85fa80fe8dfeeed84dc51598b92a135e/pydantic_core-2.27.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:83097677b8e3bd7eaa6775720ec8e0405f1575015a463285a92bfdfe254529ef", size = 1811340 },
+    { url = "https://files.pythonhosted.org/packages/9e/91/840ec1375e686dbae1bd80a9e46c26a1e0083e1186abc610efa3d9a36180/pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:172fce187655fece0c90d90a678424b013f8fbb0ca8b036ac266749c09438cb7", size = 1822900 },
+    { url = "https://files.pythonhosted.org/packages/f6/31/4240bc96025035500c18adc149aa6ffdf1a0062a4b525c932065ceb4d868/pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:519f29f5213271eeeeb3093f662ba2fd512b91c5f188f3bb7b27bc5973816934", size = 1869177 },
+    { url = "https://files.pythonhosted.org/packages/fa/20/02fbaadb7808be578317015c462655c317a77a7c8f0ef274bc016a784c54/pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:05e3a55d124407fffba0dd6b0c0cd056d10e983ceb4e5dbd10dda135c31071d6", size = 2038046 },
+    { url = "https://files.pythonhosted.org/packages/06/86/7f306b904e6c9eccf0668248b3f272090e49c275bc488a7b88b0823444a4/pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9c3ed807c7b91de05e63930188f19e921d1fe90de6b4f5cd43ee7fcc3525cb8c", size = 2685386 },
+    { url = "https://files.pythonhosted.org/packages/8d/f0/49129b27c43396581a635d8710dae54a791b17dfc50c70164866bbf865e3/pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6fb4aadc0b9a0c063206846d603b92030eb6f03069151a625667f982887153e2", size = 1997060 },
+    { url = "https://files.pythonhosted.org/packages/0d/0f/943b4af7cd416c477fd40b187036c4f89b416a33d3cc0ab7b82708a667aa/pydantic_core-2.27.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:28ccb213807e037460326424ceb8b5245acb88f32f3d2777427476e1b32c48c4", size = 2004870 },
+    { url = "https://files.pythonhosted.org/packages/35/40/aea70b5b1a63911c53a4c8117c0a828d6790483f858041f47bab0b779f44/pydantic_core-2.27.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:de3cd1899e2c279b140adde9357c4495ed9d47131b4a4eaff9052f23398076b3", size = 1999822 },
+    { url = "https://files.pythonhosted.org/packages/f2/b3/807b94fd337d58effc5498fd1a7a4d9d59af4133e83e32ae39a96fddec9d/pydantic_core-2.27.2-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:220f892729375e2d736b97d0e51466252ad84c51857d4d15f5e9692f9ef12be4", size = 2130364 },
+    { url = "https://files.pythonhosted.org/packages/fc/df/791c827cd4ee6efd59248dca9369fb35e80a9484462c33c6649a8d02b565/pydantic_core-2.27.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:a0fcd29cd6b4e74fe8ddd2c90330fd8edf2e30cb52acda47f06dd615ae72da57", size = 2158303 },
+    { url = "https://files.pythonhosted.org/packages/9b/67/4e197c300976af185b7cef4c02203e175fb127e414125916bf1128b639a9/pydantic_core-2.27.2-cp312-cp312-win32.whl", hash = "sha256:1e2cb691ed9834cd6a8be61228471d0a503731abfb42f82458ff27be7b2186fc", size = 1834064 },
+    { url = "https://files.pythonhosted.org/packages/1f/ea/cd7209a889163b8dcca139fe32b9687dd05249161a3edda62860430457a5/pydantic_core-2.27.2-cp312-cp312-win_amd64.whl", hash = "sha256:cc3f1a99a4f4f9dd1de4fe0312c114e740b5ddead65bb4102884b384c15d8bc9", size = 1989046 },
+    { url = "https://files.pythonhosted.org/packages/bc/49/c54baab2f4658c26ac633d798dab66b4c3a9bbf47cff5284e9c182f4137a/pydantic_core-2.27.2-cp312-cp312-win_arm64.whl", hash = "sha256:3911ac9284cd8a1792d3cb26a2da18f3ca26c6908cc434a18f730dc0db7bfa3b", size = 1885092 },
+    { url = "https://files.pythonhosted.org/packages/41/b1/9bc383f48f8002f99104e3acff6cba1231b29ef76cfa45d1506a5cad1f84/pydantic_core-2.27.2-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:7d14bd329640e63852364c306f4d23eb744e0f8193148d4044dd3dacdaacbd8b", size = 1892709 },
+    { url = "https://files.pythonhosted.org/packages/10/6c/e62b8657b834f3eb2961b49ec8e301eb99946245e70bf42c8817350cbefc/pydantic_core-2.27.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:82f91663004eb8ed30ff478d77c4d1179b3563df6cdb15c0817cd1cdaf34d154", size = 1811273 },
+    { url = "https://files.pythonhosted.org/packages/ba/15/52cfe49c8c986e081b863b102d6b859d9defc63446b642ccbbb3742bf371/pydantic_core-2.27.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:71b24c7d61131bb83df10cc7e687433609963a944ccf45190cfc21e0887b08c9", size = 1823027 },
+    { url = "https://files.pythonhosted.org/packages/b1/1c/b6f402cfc18ec0024120602bdbcebc7bdd5b856528c013bd4d13865ca473/pydantic_core-2.27.2-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:fa8e459d4954f608fa26116118bb67f56b93b209c39b008277ace29937453dc9", size = 1868888 },
+    { url = "https://files.pythonhosted.org/packages/bd/7b/8cb75b66ac37bc2975a3b7de99f3c6f355fcc4d89820b61dffa8f1e81677/pydantic_core-2.27.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ce8918cbebc8da707ba805b7fd0b382816858728ae7fe19a942080c24e5b7cd1", size = 2037738 },
+    { url = "https://files.pythonhosted.org/packages/c8/f1/786d8fe78970a06f61df22cba58e365ce304bf9b9f46cc71c8c424e0c334/pydantic_core-2.27.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:eda3f5c2a021bbc5d976107bb302e0131351c2ba54343f8a496dc8783d3d3a6a", size = 2685138 },
+    { url = "https://files.pythonhosted.org/packages/a6/74/d12b2cd841d8724dc8ffb13fc5cef86566a53ed358103150209ecd5d1999/pydantic_core-2.27.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bd8086fa684c4775c27f03f062cbb9eaa6e17f064307e86b21b9e0abc9c0f02e", size = 1997025 },
+    { url = "https://files.pythonhosted.org/packages/a0/6e/940bcd631bc4d9a06c9539b51f070b66e8f370ed0933f392db6ff350d873/pydantic_core-2.27.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:8d9b3388db186ba0c099a6d20f0604a44eabdeef1777ddd94786cdae158729e4", size = 2004633 },
+    { url = "https://files.pythonhosted.org/packages/50/cc/a46b34f1708d82498c227d5d80ce615b2dd502ddcfd8376fc14a36655af1/pydantic_core-2.27.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:7a66efda2387de898c8f38c0cf7f14fca0b51a8ef0b24bfea5849f1b3c95af27", size = 1999404 },
+    { url = "https://files.pythonhosted.org/packages/ca/2d/c365cfa930ed23bc58c41463bae347d1005537dc8db79e998af8ba28d35e/pydantic_core-2.27.2-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:18a101c168e4e092ab40dbc2503bdc0f62010e95d292b27827871dc85450d7ee", size = 2130130 },
+    { url = "https://files.pythonhosted.org/packages/f4/d7/eb64d015c350b7cdb371145b54d96c919d4db516817f31cd1c650cae3b21/pydantic_core-2.27.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:ba5dd002f88b78a4215ed2f8ddbdf85e8513382820ba15ad5ad8955ce0ca19a1", size = 2157946 },
+    { url = "https://files.pythonhosted.org/packages/a4/99/bddde3ddde76c03b65dfd5a66ab436c4e58ffc42927d4ff1198ffbf96f5f/pydantic_core-2.27.2-cp313-cp313-win32.whl", hash = "sha256:1ebaf1d0481914d004a573394f4be3a7616334be70261007e47c2a6fe7e50130", size = 1834387 },
+    { url = "https://files.pythonhosted.org/packages/71/47/82b5e846e01b26ac6f1893d3c5f9f3a2eb6ba79be26eef0b759b4fe72946/pydantic_core-2.27.2-cp313-cp313-win_amd64.whl", hash = "sha256:953101387ecf2f5652883208769a79e48db18c6df442568a0b5ccd8c2723abee", size = 1990453 },
+    { url = "https://files.pythonhosted.org/packages/51/b2/b2b50d5ecf21acf870190ae5d093602d95f66c9c31f9d5de6062eb329ad1/pydantic_core-2.27.2-cp313-cp313-win_arm64.whl", hash = "sha256:ac4dbfd1691affb8f48c2c13241a2e3b60ff23247cbcf981759c768b6633cf8b", size = 1885186 },
+]
+
+[[package]]
+name = "pydantic-settings"
+version = "2.8.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pydantic" },
+    { name = "python-dotenv" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/88/82/c79424d7d8c29b994fb01d277da57b0a9b09cc03c3ff875f9bd8a86b2145/pydantic_settings-2.8.1.tar.gz", hash = "sha256:d5c663dfbe9db9d5e1c646b2e161da12f0d734d422ee56f567d0ea2cee4e8585", size = 83550 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0b/53/a64f03044927dc47aafe029c42a5b7aabc38dfb813475e0e1bf71c4a59d0/pydantic_settings-2.8.1-py3-none-any.whl", hash = "sha256:81942d5ac3d905f7f3ee1a70df5dfb62d5569c12f51a5a647defc1c3d9ee2e9c", size = 30839 },
+]
+
+[[package]]
+name = "python-dotenv"
+version = "1.0.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/bc/57/e84d88dfe0aec03b7a2d4327012c1627ab5f03652216c63d49846d7a6c58/python-dotenv-1.0.1.tar.gz", hash = "sha256:e324ee90a023d808f1959c46bcbc04446a10ced277783dc6ee09987c37ec10ca", size = 39115 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6a/3e/b68c118422ec867fa7ab88444e1274aa40681c606d59ac27de5a5588f082/python_dotenv-1.0.1-py3-none-any.whl", hash = "sha256:f7b63ef50f1b690dddf550d03497b66d609393b40b564ed0d674909a68ebf16a", size = 19863 },
+]
+
+[[package]]
+name = "requests"
+version = "2.32.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "charset-normalizer" },
+    { name = "idna" },
+    { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/63/70/2bf7780ad2d390a8d301ad0b550f1581eadbd9a20f896afe06353c2a2913/requests-2.32.3.tar.gz", hash = "sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760", size = 131218 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f9/9b/335f9764261e915ed497fcdeb11df5dfd6f7bf257d4a6a2a686d80da4d54/requests-2.32.3-py3-none-any.whl", hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6", size = 64928 },
+]
+
+[[package]]
+name = "requests-toolbelt"
+version = "1.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "requests" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f3/61/d7545dafb7ac2230c70d38d31cbfe4cc64f7144dc41f6e4e4b78ecd9f5bb/requests-toolbelt-1.0.0.tar.gz", hash = "sha256:7681a0a3d047012b5bdc0ee37d7f8f07ebe76ab08caeccfc3921ce23c88d5bc6", size = 206888 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3f/51/d4db610ef29373b879047326cbf6fa98b6c1969d6f6dc423279de2b1be2c/requests_toolbelt-1.0.0-py2.py3-none-any.whl", hash = "sha256:cccfdd665f0a24fcf4726e690f65639d272bb0637b9b92dfd91a5568ccf6bd06", size = 54481 },
+]
+
+[[package]]
+name = "ruff"
+version = "0.4.10"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ea/04/b660bc832ebfa40e1788edf6934388340751cbc6f733d1f807edca9d96e6/ruff-0.4.10.tar.gz", hash = "sha256:3aa4f2bc388a30d346c56524f7cacca85945ba124945fe489952aadb6b5cd804", size = 2577674 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/53/0d/134fdd72f566d37b0c59b6e55f60993c705f93a0fe3c1faa6f8a269057c7/ruff-0.4.10-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:5c2c4d0859305ac5a16310eec40e4e9a9dec5dcdfbe92697acd99624e8638dac", size = 8510271 },
+    { url = "https://files.pythonhosted.org/packages/46/5e/4ac799ffec39ef5012052c1f144a0f7a63a0322ebd328b802d64beb3d091/ruff-0.4.10-py3-none-macosx_11_0_arm64.whl", hash = "sha256:a79489607d1495685cdd911a323a35871abfb7a95d4f98fc6f85e799227ac46e", size = 8107776 },
+    { url = "https://files.pythonhosted.org/packages/78/6f/37af054d3ced5a6196201f6c248eeaec6b3b844136cf3da510d591dbfd89/ruff-0.4.10-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b1dd1681dfa90a41b8376a61af05cc4dc5ff32c8f14f5fe20dba9ff5deb80cd6", size = 9868358 },
+    { url = "https://files.pythonhosted.org/packages/c7/38/070baf0393ba0da9d85409bdd63874776926acfc372e8e9f0ed21957aeee/ruff-0.4.10-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c75c53bb79d71310dc79fb69eb4902fba804a81f374bc86a9b117a8d077a1784", size = 9172824 },
+    { url = "https://files.pythonhosted.org/packages/e7/9d/bad51d81c918e1ce1648b24480a63f5605662efe69b55fad05825b5711ff/ruff-0.4.10-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:18238c80ee3d9100d3535d8eb15a59c4a0753b45cc55f8bf38f38d6a597b9739", size = 9997887 },
+    { url = "https://files.pythonhosted.org/packages/ec/a4/1310b3d003cb67f3c86cb8cc5c5e475dab152b1eef88558abd11e55daaad/ruff-0.4.10-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:d8f71885bce242da344989cae08e263de29752f094233f932d4f5cfb4ef36a81", size = 10743762 },
+    { url = "https://files.pythonhosted.org/packages/b8/c1/5373bc5a4c3782c0a368ce5ca4ec3a689574daf71f68f55720a6a64321d4/ruff-0.4.10-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:330421543bd3222cdfec481e8ff3460e8702ed1e58b494cf9d9e4bf90db52b9d", size = 10329524 },
+    { url = "https://files.pythonhosted.org/packages/48/dc/2c057e7717a3eaaa89ea848a26ef085930a2509f9b66ceae55319668c03d/ruff-0.4.10-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9e9b6fb3a37b772628415b00c4fc892f97954275394ed611056a4b8a2631365e", size = 11208593 },
+    { url = "https://files.pythonhosted.org/packages/11/c3/3f89b1e967a869642bd9198f27e2b89b8300862555d3e1e39b4ccaf92e8b/ruff-0.4.10-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0f54c481b39a762d48f64d97351048e842861c6662d63ec599f67d515cb417f6", size = 10041835 },
+    { url = "https://files.pythonhosted.org/packages/d0/e6/734aed23112de8df5a2f3bc02e9e45cd3910fe83b0d2bb2456e200c52d98/ruff-0.4.10-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:67fe086b433b965c22de0b4259ddfe6fa541c95bf418499bedb9ad5fb8d1c631", size = 9842683 },
+    { url = "https://files.pythonhosted.org/packages/cf/13/bc788b2e21d3e4db74d1375da22f50f944bc1fef064c4749f307b0c8794f/ruff-0.4.10-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:acfaaab59543382085f9eb51f8e87bac26bf96b164839955f244d07125a982ef", size = 9283929 },
+    { url = "https://files.pythonhosted.org/packages/f0/09/f3c6560f9d81a4c5d800996090c9cc54d794ea14ab8f8af46b7483005963/ruff-0.4.10-py3-none-musllinux_1_2_i686.whl", hash = "sha256:3cea07079962b2941244191569cf3a05541477286f5cafea638cd3aa94b56815", size = 9617526 },
+    { url = "https://files.pythonhosted.org/packages/d3/9e/11ae4e8587efe40aa083835665d0818626f8f4a10aa4ebc097cdbfae7624/ruff-0.4.10-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:338a64ef0748f8c3a80d7f05785930f7965d71ca260904a9321d13be24b79695", size = 10114053 },
+    { url = "https://files.pythonhosted.org/packages/e8/94/3bb62a0086e9c61d0506e546e7cf68456fd93bf569a8adfa5e324812970d/ruff-0.4.10-py3-none-win32.whl", hash = "sha256:ffe3cd2f89cb54561c62e5fa20e8f182c0a444934bf430515a4b422f1ab7b7ca", size = 7707741 },
+    { url = "https://files.pythonhosted.org/packages/d8/4e/6fd32ebd0a09f25ed9911b77c5273b7a6b3b50a78d6ed0508d66a24398b8/ruff-0.4.10-py3-none-win_amd64.whl", hash = "sha256:67f67cef43c55ffc8cc59e8e0b97e9e60b4837c8f21e8ab5ffd5d66e196e25f7", size = 8519153 },
+    { url = "https://files.pythonhosted.org/packages/dc/78/5109b7db3b44a64157b025e45eec6591e4beb53732104637d8e0ee0c5570/ruff-0.4.10-py3-none-win_arm64.whl", hash = "sha256:dd1fcee327c20addac7916ca4e2653fbbf2e8388d8a6477ce5b4e986b68ae6c0", size = 7906942 },
+]
+
+[[package]]
+name = "sniffio"
+version = "1.3.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235 },
+]
+
+[[package]]
+name = "speckle-blender"
+version = "3.0.0"
+source = { virtual = "." }
+dependencies = [
+    { name = "specklepy" },
+]
+
+[package.dev-dependencies]
+dev = [
+    { name = "fake-bpy-module-latest" },
+    { name = "ruff" },
+]
+
+[package.metadata]
+requires-dist = [{ name = "specklepy", specifier = ">=3.0.0a3" }]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "fake-bpy-module-latest", specifier = ">=20240524,<20240525" },
+    { name = "ruff", specifier = ">=0.4.4,<0.5" },
+]
+
+[[package]]
+name = "specklepy"
+version = "3.0.0a3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "appdirs" },
+    { name = "attrs" },
+    { name = "deprecated" },
+    { name = "gql", extra = ["requests", "websockets"] },
+    { name = "httpx" },
+    { name = "pydantic" },
+    { name = "pydantic-settings" },
+    { name = "stringcase" },
+    { name = "ujson" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/43/83/e4d9bb86c3a00dbbe00db53ace96710439a5f208440898ba2fe152874d72/specklepy-3.0.0a3.tar.gz", hash = "sha256:27f8b4553e748251d09a39fa2d4f75bfedaed46bff457730e8b2b73654a041b9", size = 199614 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8a/30/89e57b11b6908057c95e015fe66f024d8c60fbb50368d9fb8608e316cdf8/specklepy-3.0.0a3-py3-none-any.whl", hash = "sha256:6d342c138807b310d3b27995cde6ac955cba4c2e6735b01dee3376f9e1db874d", size = 110320 },
+]
+
+[[package]]
+name = "stringcase"
+version = "1.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f3/1f/1241aa3d66e8dc1612427b17885f5fcd9c9ee3079fc0d28e9a3aeeb36fa3/stringcase-1.2.0.tar.gz", hash = "sha256:48a06980661908efe8d9d34eab2b6c13aefa2163b3ced26972902e3bdfd87008", size = 2958 }
+
+[[package]]
+name = "typing-extensions"
+version = "4.12.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/df/db/f35a00659bc03fec321ba8bce9420de607a1d37f8342eee1863174c69557/typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8", size = 85321 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/26/9f/ad63fc0248c5379346306f8668cda6e2e2e9c95e01216d2b8ffd9ff037d0/typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d", size = 37438 },
+]
+
+[[package]]
+name = "ujson"
+version = "5.10.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f0/00/3110fd566786bfa542adb7932d62035e0c0ef662a8ff6544b6643b3d6fd7/ujson-5.10.0.tar.gz", hash = "sha256:b3cd8f3c5d8c7738257f1018880444f7b7d9b66232c64649f562d7ba86ad4bc1", size = 7154885 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/23/ec/3c551ecfe048bcb3948725251fb0214b5844a12aa60bee08d78315bb1c39/ujson-5.10.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a5b366812c90e69d0f379a53648be10a5db38f9d4ad212b60af00bd4048d0f00", size = 55353 },
+    { url = "https://files.pythonhosted.org/packages/8d/9f/4731ef0671a0653e9f5ba18db7c4596d8ecbf80c7922dd5fe4150f1aea76/ujson-5.10.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:502bf475781e8167f0f9d0e41cd32879d120a524b22358e7f205294224c71126", size = 51813 },
+    { url = "https://files.pythonhosted.org/packages/1f/2b/44d6b9c1688330bf011f9abfdb08911a9dc74f76926dde74e718d87600da/ujson-5.10.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5b91b5d0d9d283e085e821651184a647699430705b15bf274c7896f23fe9c9d8", size = 51988 },
+    { url = "https://files.pythonhosted.org/packages/29/45/f5f5667427c1ec3383478092a414063ddd0dfbebbcc533538fe37068a0a3/ujson-5.10.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:129e39af3a6d85b9c26d5577169c21d53821d8cf68e079060602e861c6e5da1b", size = 53561 },
+    { url = "https://files.pythonhosted.org/packages/26/21/a0c265cda4dd225ec1be595f844661732c13560ad06378760036fc622587/ujson-5.10.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f77b74475c462cb8b88680471193064d3e715c7c6074b1c8c412cb526466efe9", size = 58497 },
+    { url = "https://files.pythonhosted.org/packages/28/36/8fde862094fd2342ccc427a6a8584fed294055fdee341661c78660f7aef3/ujson-5.10.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7ec0ca8c415e81aa4123501fee7f761abf4b7f386aad348501a26940beb1860f", size = 997877 },
+    { url = "https://files.pythonhosted.org/packages/90/37/9208e40d53baa6da9b6a1c719e0670c3f474c8fc7cc2f1e939ec21c1bc93/ujson-5.10.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:ab13a2a9e0b2865a6c6db9271f4b46af1c7476bfd51af1f64585e919b7c07fd4", size = 1140632 },
+    { url = "https://files.pythonhosted.org/packages/89/d5/2626c87c59802863d44d19e35ad16b7e658e4ac190b0dead17ff25460b4c/ujson-5.10.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:57aaf98b92d72fc70886b5a0e1a1ca52c2320377360341715dd3933a18e827b1", size = 1043513 },
+    { url = "https://files.pythonhosted.org/packages/2f/ee/03662ce9b3f16855770f0d70f10f0978ba6210805aa310c4eebe66d36476/ujson-5.10.0-cp311-cp311-win32.whl", hash = "sha256:2987713a490ceb27edff77fb184ed09acdc565db700ee852823c3dc3cffe455f", size = 38616 },
+    { url = "https://files.pythonhosted.org/packages/3e/20/952dbed5895835ea0b82e81a7be4ebb83f93b079d4d1ead93fcddb3075af/ujson-5.10.0-cp311-cp311-win_amd64.whl", hash = "sha256:f00ea7e00447918ee0eff2422c4add4c5752b1b60e88fcb3c067d4a21049a720", size = 42071 },
+    { url = "https://files.pythonhosted.org/packages/e8/a6/fd3f8bbd80842267e2d06c3583279555e8354c5986c952385199d57a5b6c/ujson-5.10.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:98ba15d8cbc481ce55695beee9f063189dce91a4b08bc1d03e7f0152cd4bbdd5", size = 55642 },
+    { url = "https://files.pythonhosted.org/packages/a8/47/dd03fd2b5ae727e16d5d18919b383959c6d269c7b948a380fdd879518640/ujson-5.10.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a9d2edbf1556e4f56e50fab7d8ff993dbad7f54bac68eacdd27a8f55f433578e", size = 51807 },
+    { url = "https://files.pythonhosted.org/packages/25/23/079a4cc6fd7e2655a473ed9e776ddbb7144e27f04e8fc484a0fb45fe6f71/ujson-5.10.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6627029ae4f52d0e1a2451768c2c37c0c814ffc04f796eb36244cf16b8e57043", size = 51972 },
+    { url = "https://files.pythonhosted.org/packages/04/81/668707e5f2177791869b624be4c06fb2473bf97ee33296b18d1cf3092af7/ujson-5.10.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f8ccb77b3e40b151e20519c6ae6d89bfe3f4c14e8e210d910287f778368bb3d1", size = 53686 },
+    { url = "https://files.pythonhosted.org/packages/bd/50/056d518a386d80aaf4505ccf3cee1c40d312a46901ed494d5711dd939bc3/ujson-5.10.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f3caf9cd64abfeb11a3b661329085c5e167abbe15256b3b68cb5d914ba7396f3", size = 58591 },
+    { url = "https://files.pythonhosted.org/packages/fc/d6/aeaf3e2d6fb1f4cfb6bf25f454d60490ed8146ddc0600fae44bfe7eb5a72/ujson-5.10.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6e32abdce572e3a8c3d02c886c704a38a1b015a1fb858004e03d20ca7cecbb21", size = 997853 },
+    { url = "https://files.pythonhosted.org/packages/f8/d5/1f2a5d2699f447f7d990334ca96e90065ea7f99b142ce96e85f26d7e78e2/ujson-5.10.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:a65b6af4d903103ee7b6f4f5b85f1bfd0c90ba4eeac6421aae436c9988aa64a2", size = 1140689 },
+    { url = "https://files.pythonhosted.org/packages/f2/2c/6990f4ccb41ed93744aaaa3786394bca0875503f97690622f3cafc0adfde/ujson-5.10.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:604a046d966457b6cdcacc5aa2ec5314f0e8c42bae52842c1e6fa02ea4bda42e", size = 1043576 },
+    { url = "https://files.pythonhosted.org/packages/14/f5/a2368463dbb09fbdbf6a696062d0c0f62e4ae6fa65f38f829611da2e8fdd/ujson-5.10.0-cp312-cp312-win32.whl", hash = "sha256:6dea1c8b4fc921bf78a8ff00bbd2bfe166345f5536c510671bccececb187c80e", size = 38764 },
+    { url = "https://files.pythonhosted.org/packages/59/2d/691f741ffd72b6c84438a93749ac57bf1a3f217ac4b0ea4fd0e96119e118/ujson-5.10.0-cp312-cp312-win_amd64.whl", hash = "sha256:38665e7d8290188b1e0d57d584eb8110951a9591363316dd41cf8686ab1d0abc", size = 42211 },
+    { url = "https://files.pythonhosted.org/packages/0d/69/b3e3f924bb0e8820bb46671979770c5be6a7d51c77a66324cdb09f1acddb/ujson-5.10.0-cp313-cp313-macosx_10_9_x86_64.whl", hash = "sha256:618efd84dc1acbd6bff8eaa736bb6c074bfa8b8a98f55b61c38d4ca2c1f7f287", size = 55646 },
+    { url = "https://files.pythonhosted.org/packages/32/8a/9b748eb543c6cabc54ebeaa1f28035b1bd09c0800235b08e85990734c41e/ujson-5.10.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:38d5d36b4aedfe81dfe251f76c0467399d575d1395a1755de391e58985ab1c2e", size = 51806 },
+    { url = "https://files.pythonhosted.org/packages/39/50/4b53ea234413b710a18b305f465b328e306ba9592e13a791a6a6b378869b/ujson-5.10.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:67079b1f9fb29ed9a2914acf4ef6c02844b3153913eb735d4bf287ee1db6e557", size = 51975 },
+    { url = "https://files.pythonhosted.org/packages/b4/9d/8061934f960cdb6dd55f0b3ceeff207fcc48c64f58b43403777ad5623d9e/ujson-5.10.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d7d0e0ceeb8fe2468c70ec0c37b439dd554e2aa539a8a56365fd761edb418988", size = 53693 },
+    { url = "https://files.pythonhosted.org/packages/f5/be/7bfa84b28519ddbb67efc8410765ca7da55e6b93aba84d97764cd5794dbc/ujson-5.10.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:59e02cd37bc7c44d587a0ba45347cc815fb7a5fe48de16bf05caa5f7d0d2e816", size = 58594 },
+    { url = "https://files.pythonhosted.org/packages/48/eb/85d465abafb2c69d9699cfa5520e6e96561db787d36c677370e066c7e2e7/ujson-5.10.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:2a890b706b64e0065f02577bf6d8ca3b66c11a5e81fb75d757233a38c07a1f20", size = 997853 },
+    { url = "https://files.pythonhosted.org/packages/9f/76/2a63409fc05d34dd7d929357b7a45e3a2c96f22b4225cd74becd2ba6c4cb/ujson-5.10.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:621e34b4632c740ecb491efc7f1fcb4f74b48ddb55e65221995e74e2d00bbff0", size = 1140694 },
+    { url = "https://files.pythonhosted.org/packages/45/ed/582c4daba0f3e1688d923b5cb914ada1f9defa702df38a1916c899f7c4d1/ujson-5.10.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b9500e61fce0cfc86168b248104e954fead61f9be213087153d272e817ec7b4f", size = 1043580 },
+    { url = "https://files.pythonhosted.org/packages/d7/0c/9837fece153051e19c7bade9f88f9b409e026b9525927824cdf16293b43b/ujson-5.10.0-cp313-cp313-win32.whl", hash = "sha256:4c4fc16f11ac1612f05b6f5781b384716719547e142cfd67b65d035bd85af165", size = 38766 },
+    { url = "https://files.pythonhosted.org/packages/d7/72/6cb6728e2738c05bbe9bd522d6fc79f86b9a28402f38663e85a28fddd4a0/ujson-5.10.0-cp313-cp313-win_amd64.whl", hash = "sha256:4573fd1695932d4f619928fd09d5d03d917274381649ade4328091ceca175539", size = 42212 },
+]
+
+[[package]]
+name = "urllib3"
+version = "2.2.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ed/63/22ba4ebfe7430b76388e7cd448d5478814d3032121827c12a2cc287e2260/urllib3-2.2.3.tar.gz", hash = "sha256:e7d814a81dad81e6caf2ec9fdedb284ecc9c73076b62654547cc64ccdcae26e9", size = 300677 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ce/d9/5f4c13cecde62396b0d3fe530a50ccea91e7dfc1ccf0e09c228841bb5ba8/urllib3-2.2.3-py3-none-any.whl", hash = "sha256:ca899ca043dcb1bafa3e262d73aa25c465bfb49e0bd9dd5d59f1d0acba2f8fac", size = 126338 },
+]
+
+[[package]]
+name = "websockets"
+version = "11.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/3b/2ed38e52eed4cf277f9df5f0463a99199a04d9e29c9e227cfafa57bd3993/websockets-11.0.3.tar.gz", hash = "sha256:88fc51d9a26b10fc331be344f1781224a375b78488fc343620184e95a4b27016", size = 104235 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/16/49/ae616bd221efba84a3d78737b417f704af1ffa36f40dcaba5eb954dd4753/websockets-11.0.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:e848f46a58b9fcf3d06061d17be388caf70ea5b8cc3466251963c8345e13f7eb", size = 123748 },
+    { url = "https://files.pythonhosted.org/packages/0a/84/68b848a373493b58615d6c10e9e8ccbaadfd540f84905421739a807704f8/websockets-11.0.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:aa5003845cdd21ac0dc6c9bf661c5beddd01116f6eb9eb3c8e272353d45b3288", size = 120975 },
+    { url = "https://files.pythonhosted.org/packages/8c/a8/e81533499f84ef6cdd95d11d5b05fa827c0f097925afd86f16e6a2631d8e/websockets-11.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:b58cbf0697721120866820b89f93659abc31c1e876bf20d0b3d03cef14faf84d", size = 121017 },
+    { url = "https://files.pythonhosted.org/packages/6b/ca/65d6986665888494eca4d5435a9741c822022996f0f4200c57ce4b9242f7/websockets-11.0.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:660e2d9068d2bedc0912af508f30bbeb505bbbf9774d98def45f68278cea20d3", size = 131200 },
+    { url = "https://files.pythonhosted.org/packages/c0/a8/a8a582ebeeecc8b5f332997d44c57e241748f8a9856e06a38a5a13b30796/websockets-11.0.3-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c1f0524f203e3bd35149f12157438f406eff2e4fb30f71221c8a5eceb3617b6b", size = 130195 },
+    { url = "https://files.pythonhosted.org/packages/a9/5e/b25c60067d700e811dccb4e3c318eeadd3a19d8b3620de9f97434af777a7/websockets-11.0.3-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:def07915168ac8f7853812cc593c71185a16216e9e4fa886358a17ed0fd9fcf6", size = 130569 },
+    { url = "https://files.pythonhosted.org/packages/14/fc/5cbbf439c925e1e184a0392ec477a30cee2fabc0e63807c1d4b6d570fb52/websockets-11.0.3-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:b30c6590146e53149f04e85a6e4fcae068df4289e31e4aee1fdf56a0dead8f97", size = 136015 },
+    { url = "https://files.pythonhosted.org/packages/0f/d8/a997d3546aef9cc995a1126f7d7ade96c0e16c1a0efb9d2d430aee57c925/websockets-11.0.3-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:619d9f06372b3a42bc29d0cd0354c9bb9fb39c2cbc1a9c5025b4538738dbffaf", size = 135292 },
+    { url = "https://files.pythonhosted.org/packages/89/8f/707a05d5725f956c78d252a5fd73b89fa3ac57dd3959381c2d1acb41cb13/websockets-11.0.3-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:01f5567d9cf6f502d655151645d4e8b72b453413d3819d2b6f1185abc23e82dd", size = 135890 },
+    { url = "https://files.pythonhosted.org/packages/b5/94/ac47552208583d5dbcce468430c1eb2ae18962f6b3a694a2b7727cc60d4a/websockets-11.0.3-cp311-cp311-win32.whl", hash = "sha256:e1459677e5d12be8bbc7584c35b992eea142911a6236a3278b9b5ce3326f282c", size = 124149 },
+    { url = "https://files.pythonhosted.org/packages/e1/7c/0ad6e7ef0a054d73092f616d20d3d9bd3e1b837554cb20a52d8dd9f5b049/websockets-11.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:e7837cb169eca3b3ae94cc5787c4fed99eef74c0ab9506756eea335e0d6f3ed8", size = 124670 },
+    { url = "https://files.pythonhosted.org/packages/47/96/9d5749106ff57629b54360664ae7eb9afd8302fad1680ead385383e33746/websockets-11.0.3-py3-none-any.whl", hash = "sha256:6681ba9e7f8f3b19440921e99efbb40fc89f26cd71bf539e45d8c8a25c976dc6", size = 118056 },
+]
+
+[[package]]
+name = "wrapt"
+version = "1.17.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/24/a1/fc03dca9b0432725c2e8cdbf91a349d2194cf03d8523c124faebe581de09/wrapt-1.17.0.tar.gz", hash = "sha256:16187aa2317c731170a88ef35e8937ae0f533c402872c1ee5e6d079fcf320801", size = 55542 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0e/40/def56538acddc2f764c157d565b9f989072a1d2f2a8e384324e2e104fc7d/wrapt-1.17.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:74bf625b1b4caaa7bad51d9003f8b07a468a704e0644a700e936c357c17dd45a", size = 38766 },
+    { url = "https://files.pythonhosted.org/packages/89/e2/8c299f384ae4364193724e2adad99f9504599d02a73ec9199bf3f406549d/wrapt-1.17.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0f2a28eb35cf99d5f5bd12f5dd44a0f41d206db226535b37b0c60e9da162c3ed", size = 83730 },
+    { url = "https://files.pythonhosted.org/packages/29/ef/fcdb776b12df5ea7180d065b28fa6bb27ac785dddcd7202a0b6962bbdb47/wrapt-1.17.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:81b1289e99cf4bad07c23393ab447e5e96db0ab50974a280f7954b071d41b489", size = 75470 },
+    { url = "https://files.pythonhosted.org/packages/55/b5/698bd0bf9fbb3ddb3a2feefbb7ad0dea1205f5d7d05b9cbab54f5db731aa/wrapt-1.17.0-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9f2939cd4a2a52ca32bc0b359015718472d7f6de870760342e7ba295be9ebaf9", size = 83168 },
+    { url = "https://files.pythonhosted.org/packages/ce/07/701a5cee28cb4d5df030d4b2649319e36f3d9fdd8000ef1d84eb06b9860d/wrapt-1.17.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6a9653131bda68a1f029c52157fd81e11f07d485df55410401f745007bd6d339", size = 82307 },
+    { url = "https://files.pythonhosted.org/packages/42/92/c48ba92cda6f74cb914dc3c5bba9650dc80b790e121c4b987f3a46b028f5/wrapt-1.17.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:4e4b4385363de9052dac1a67bfb535c376f3d19c238b5f36bddc95efae15e12d", size = 75101 },
+    { url = "https://files.pythonhosted.org/packages/8a/0a/9276d3269334138b88a2947efaaf6335f61d547698e50dff672ade24f2c6/wrapt-1.17.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:bdf62d25234290db1837875d4dceb2151e4ea7f9fff2ed41c0fde23ed542eb5b", size = 81835 },
+    { url = "https://files.pythonhosted.org/packages/b9/4c/39595e692753ef656ea94b51382cc9aea662fef59d7910128f5906486f0e/wrapt-1.17.0-cp311-cp311-win32.whl", hash = "sha256:5d8fd17635b262448ab8f99230fe4dac991af1dabdbb92f7a70a6afac8a7e346", size = 36412 },
+    { url = "https://files.pythonhosted.org/packages/63/bb/c293a67fb765a2ada48f48cd0f2bb957da8161439da4c03ea123b9894c02/wrapt-1.17.0-cp311-cp311-win_amd64.whl", hash = "sha256:92a3d214d5e53cb1db8b015f30d544bc9d3f7179a05feb8f16df713cecc2620a", size = 38744 },
+    { url = "https://files.pythonhosted.org/packages/85/82/518605474beafff11f1a34759f6410ab429abff9f7881858a447e0d20712/wrapt-1.17.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:89fc28495896097622c3fc238915c79365dd0ede02f9a82ce436b13bd0ab7569", size = 38904 },
+    { url = "https://files.pythonhosted.org/packages/80/6c/17c3b2fed28edfd96d8417c865ef0b4c955dc52c4e375d86f459f14340f1/wrapt-1.17.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:875d240fdbdbe9e11f9831901fb8719da0bd4e6131f83aa9f69b96d18fae7504", size = 88622 },
+    { url = "https://files.pythonhosted.org/packages/4a/11/60ecdf3b0fd3dca18978d89acb5d095a05f23299216e925fcd2717c81d93/wrapt-1.17.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e5ed16d95fd142e9c72b6c10b06514ad30e846a0d0917ab406186541fe68b451", size = 80920 },
+    { url = "https://files.pythonhosted.org/packages/d2/50/dbef1a651578a3520d4534c1e434989e3620380c1ad97e309576b47f0ada/wrapt-1.17.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:18b956061b8db634120b58f668592a772e87e2e78bc1f6a906cfcaa0cc7991c1", size = 89170 },
+    { url = "https://files.pythonhosted.org/packages/44/a2/78c5956bf39955288c9e0dd62e807b308c3aa15a0f611fbff52aa8d6b5ea/wrapt-1.17.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:daba396199399ccabafbfc509037ac635a6bc18510ad1add8fd16d4739cdd106", size = 86748 },
+    { url = "https://files.pythonhosted.org/packages/99/49/2ee413c78fc0bdfebe5bee590bf3becdc1fab0096a7a9c3b5c9666b2415f/wrapt-1.17.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:4d63f4d446e10ad19ed01188d6c1e1bb134cde8c18b0aa2acfd973d41fcc5ada", size = 79734 },
+    { url = "https://files.pythonhosted.org/packages/c0/8c/4221b7b270e36be90f0930fe15a4755a6ea24093f90b510166e9ed7861ea/wrapt-1.17.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:8a5e7cc39a45fc430af1aefc4d77ee6bad72c5bcdb1322cfde852c15192b8bd4", size = 87552 },
+    { url = "https://files.pythonhosted.org/packages/4c/6b/1aaccf3efe58eb95e10ce8e77c8909b7a6b0da93449a92c4e6d6d10b3a3d/wrapt-1.17.0-cp312-cp312-win32.whl", hash = "sha256:0a0a1a1ec28b641f2a3a2c35cbe86c00051c04fffcfcc577ffcdd707df3f8635", size = 36647 },
+    { url = "https://files.pythonhosted.org/packages/b3/4f/243f88ac49df005b9129194c6511b3642818b3e6271ddea47a15e2ee4934/wrapt-1.17.0-cp312-cp312-win_amd64.whl", hash = "sha256:3c34f6896a01b84bab196f7119770fd8466c8ae3dfa73c59c0bb281e7b588ce7", size = 38830 },
+    { url = "https://files.pythonhosted.org/packages/67/9c/38294e1bb92b055222d1b8b6591604ca4468b77b1250f59c15256437644f/wrapt-1.17.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:714c12485aa52efbc0fc0ade1e9ab3a70343db82627f90f2ecbc898fdf0bb181", size = 38904 },
+    { url = "https://files.pythonhosted.org/packages/78/b6/76597fb362cbf8913a481d41b14b049a8813cd402a5d2f84e57957c813ae/wrapt-1.17.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da427d311782324a376cacb47c1a4adc43f99fd9d996ffc1b3e8529c4074d393", size = 88608 },
+    { url = "https://files.pythonhosted.org/packages/bc/69/b500884e45b3881926b5f69188dc542fb5880019d15c8a0df1ab1dfda1f7/wrapt-1.17.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ba1739fb38441a27a676f4de4123d3e858e494fac05868b7a281c0a383c098f4", size = 80879 },
+    { url = "https://files.pythonhosted.org/packages/52/31/f4cc58afe29eab8a50ac5969963010c8b60987e719c478a5024bce39bc42/wrapt-1.17.0-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e711fc1acc7468463bc084d1b68561e40d1eaa135d8c509a65dd534403d83d7b", size = 89119 },
+    { url = "https://files.pythonhosted.org/packages/aa/9c/05ab6bf75dbae7a9d34975fb6ee577e086c1c26cde3b6cf6051726d33c7c/wrapt-1.17.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:140ea00c87fafc42739bd74a94a5a9003f8e72c27c47cd4f61d8e05e6dec8721", size = 86778 },
+    { url = "https://files.pythonhosted.org/packages/0e/6c/4b8d42e3db355603d35fe5c9db79c28f2472a6fd1ccf4dc25ae46739672a/wrapt-1.17.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:73a96fd11d2b2e77d623a7f26e004cc31f131a365add1ce1ce9a19e55a1eef90", size = 79793 },
+    { url = "https://files.pythonhosted.org/packages/69/23/90e3a2ee210c0843b2c2a49b3b97ffcf9cad1387cb18cbeef9218631ed5a/wrapt-1.17.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:0b48554952f0f387984da81ccfa73b62e52817a4386d070c75e4db7d43a28c4a", size = 87606 },
+    { url = "https://files.pythonhosted.org/packages/5f/06/3683126491ca787d8d71d8d340e775d40767c5efedb35039d987203393b7/wrapt-1.17.0-cp313-cp313-win32.whl", hash = "sha256:498fec8da10e3e62edd1e7368f4b24aa362ac0ad931e678332d1b209aec93045", size = 36651 },
+    { url = "https://files.pythonhosted.org/packages/f1/bc/3bf6d2ca0d2c030d324ef9272bea0a8fdaff68f3d1fa7be7a61da88e51f7/wrapt-1.17.0-cp313-cp313-win_amd64.whl", hash = "sha256:fd136bb85f4568fffca995bd3c8d52080b1e5b225dbf1c2b17b66b4c5fa02838", size = 38835 },
+    { url = "https://files.pythonhosted.org/packages/ce/b5/251165c232d87197a81cd362eeb5104d661a2dd3aa1f0b33e4bf61dda8b8/wrapt-1.17.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:17fcf043d0b4724858f25b8826c36e08f9fb2e475410bece0ec44a22d533da9b", size = 40146 },
+    { url = "https://files.pythonhosted.org/packages/89/33/1e1bdd3e866eeb73d8c4755db1ceb8a80d5bd51ee4648b3f2247adec4e67/wrapt-1.17.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e4a557d97f12813dc5e18dad9fa765ae44ddd56a672bb5de4825527c847d6379", size = 113444 },
+    { url = "https://files.pythonhosted.org/packages/9f/7c/94f53b065a43f5dc1fbdd8b80fd8f41284315b543805c956619c0b8d92f0/wrapt-1.17.0-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0229b247b0fc7dee0d36176cbb79dbaf2a9eb7ecc50ec3121f40ef443155fb1d", size = 101246 },
+    { url = "https://files.pythonhosted.org/packages/62/5d/640360baac6ea6018ed5e34e6e80e33cfbae2aefde24f117587cd5efd4b7/wrapt-1.17.0-cp313-cp313t-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8425cfce27b8b20c9b89d77fb50e368d8306a90bf2b6eef2cdf5cd5083adf83f", size = 109320 },
+    { url = "https://files.pythonhosted.org/packages/e3/cf/6c7a00ae86a2e9482c91170aefe93f4ccda06c1ac86c4de637c69133da59/wrapt-1.17.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9c900108df470060174108012de06d45f514aa4ec21a191e7ab42988ff42a86c", size = 110193 },
+    { url = "https://files.pythonhosted.org/packages/cd/cc/aa718df0d20287e8f953ce0e2f70c0af0fba1d3c367db7ee8bdc46ea7003/wrapt-1.17.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:4e547b447073fc0dbfcbff15154c1be8823d10dab4ad401bdb1575e3fdedff1b", size = 100460 },
+    { url = "https://files.pythonhosted.org/packages/f7/16/9f3ac99fe1f6caaa789d67b4e3c562898b532c250769f5255fa8b8b93983/wrapt-1.17.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:914f66f3b6fc7b915d46c1cc424bc2441841083de01b90f9e81109c9759e43ab", size = 106347 },
+    { url = "https://files.pythonhosted.org/packages/64/85/c77a331b2c06af49a687f8b926fc2d111047a51e6f0b0a4baa01ff3a673a/wrapt-1.17.0-cp313-cp313t-win32.whl", hash = "sha256:a4192b45dff127c7d69b3bdfb4d3e47b64179a0b9900b6351859f3001397dabf", size = 37971 },
+    { url = "https://files.pythonhosted.org/packages/05/9b/b2469f8be9efed24283fd7b9eeb8e913e9bc0715cf919ea8645e428ab7af/wrapt-1.17.0-cp313-cp313t-win_amd64.whl", hash = "sha256:4f643df3d4419ea3f856c5c3f40fec1d65ea2e89ec812c83f7767c8730f9827a", size = 40755 },
+    { url = "https://files.pythonhosted.org/packages/4b/d9/a8ba5e9507a9af1917285d118388c5eb7a81834873f45df213a6fe923774/wrapt-1.17.0-py3-none-any.whl", hash = "sha256:d2c63b93548eda58abf5188e505ffed0229bf675f7c3090f8e36ad55b8cbc371", size = 23592 },
+]
+
+[[package]]
+name = "yarl"
+version = "1.15.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "idna" },
+    { name = "multidict" },
+    { name = "propcache" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/e1/d5427a061819c9f885f58bb0467d02a523f1aec19f9e5f9c82ce950d90d3/yarl-1.15.2.tar.gz", hash = "sha256:a39c36f4218a5bb668b4f06874d676d35a035ee668e6e7e3538835c703634b84", size = 169318 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4a/59/3ae125c97a2a8571ea16fdf59fcbd288bc169e0005d1af9946a90ea831d9/yarl-1.15.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9fcda20b2de7042cc35cf911702fa3d8311bd40055a14446c1e62403684afdc5", size = 136492 },
+    { url = "https://files.pythonhosted.org/packages/f9/2b/efa58f36b582db45b94c15e87803b775eb8a4ca0db558121a272e67f3564/yarl-1.15.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:0545de8c688fbbf3088f9e8b801157923be4bf8e7b03e97c2ecd4dfa39e48e0e", size = 88614 },
+    { url = "https://files.pythonhosted.org/packages/82/69/eb73c0453a2ff53194df485dc7427d54e6cb8d1180fcef53251a8e24d069/yarl-1.15.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:fbda058a9a68bec347962595f50546a8a4a34fd7b0654a7b9697917dc2bf810d", size = 86607 },
+    { url = "https://files.pythonhosted.org/packages/48/4e/89beaee3a4da0d1c6af1176d738cff415ff2ad3737785ee25382409fe3e3/yarl-1.15.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d1ac2bc069f4a458634c26b101c2341b18da85cb96afe0015990507efec2e417", size = 334077 },
+    { url = "https://files.pythonhosted.org/packages/da/e8/8fcaa7552093f94c3f327783e2171da0eaa71db0c267510898a575066b0f/yarl-1.15.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:cd126498171f752dd85737ab1544329a4520c53eed3997f9b08aefbafb1cc53b", size = 347365 },
+    { url = "https://files.pythonhosted.org/packages/be/fa/dc2002f82a89feab13a783d3e6b915a3a2e0e83314d9e3f6d845ee31bfcc/yarl-1.15.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3db817b4e95eb05c362e3b45dafe7144b18603e1211f4a5b36eb9522ecc62bcf", size = 344823 },
+    { url = "https://files.pythonhosted.org/packages/ae/c8/c4a00fe7f2aa6970c2651df332a14c88f8baaedb2e32d6c3b8c8a003ea74/yarl-1.15.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:076b1ed2ac819933895b1a000904f62d615fe4533a5cf3e052ff9a1da560575c", size = 337132 },
+    { url = "https://files.pythonhosted.org/packages/07/bf/84125f85f44bf2af03f3cf64e87214b42cd59dcc8a04960d610a9825f4d4/yarl-1.15.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f8cfd847e6b9ecf9f2f2531c8427035f291ec286c0a4944b0a9fce58c6446046", size = 326258 },
+    { url = "https://files.pythonhosted.org/packages/00/19/73ad8122b2fa73fe22e32c24b82a6c053cf6c73e2f649b73f7ef97bee8d0/yarl-1.15.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:32b66be100ac5739065496c74c4b7f3015cef792c3174982809274d7e51b3e04", size = 336212 },
+    { url = "https://files.pythonhosted.org/packages/39/1d/2fa4337d11f6587e9b7565f84eba549f2921494bc8b10bfe811079acaa70/yarl-1.15.2-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:34a2d76a1984cac04ff8b1bfc939ec9dc0914821264d4a9c8fd0ed6aa8d4cfd2", size = 330397 },
+    { url = "https://files.pythonhosted.org/packages/39/ab/dce75e06806bcb4305966471ead03ce639d8230f4f52c32bd614d820c044/yarl-1.15.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:0afad2cd484908f472c8fe2e8ef499facee54a0a6978be0e0cff67b1254fd747", size = 334985 },
+    { url = "https://files.pythonhosted.org/packages/c1/98/3f679149347a5e34c952bf8f71a387bc96b3488fae81399a49f8b1a01134/yarl-1.15.2-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:c68e820879ff39992c7f148113b46efcd6ec765a4865581f2902b3c43a5f4bbb", size = 356033 },
+    { url = "https://files.pythonhosted.org/packages/f7/8c/96546061c19852d0a4b1b07084a58c2e8911db6bcf7838972cff542e09fb/yarl-1.15.2-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:98f68df80ec6ca3015186b2677c208c096d646ef37bbf8b49764ab4a38183931", size = 357710 },
+    { url = "https://files.pythonhosted.org/packages/01/45/ade6fb3daf689816ebaddb3175c962731edf300425c3254c559b6d0dcc27/yarl-1.15.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3c56ec1eacd0a5d35b8a29f468659c47f4fe61b2cab948ca756c39b7617f0aa5", size = 345532 },
+    { url = "https://files.pythonhosted.org/packages/e7/d7/8de800d3aecda0e64c43e8fc844f7effc8731a6099fa0c055738a2247504/yarl-1.15.2-cp311-cp311-win32.whl", hash = "sha256:eedc3f247ee7b3808ea07205f3e7d7879bc19ad3e6222195cd5fbf9988853e4d", size = 78250 },
+    { url = "https://files.pythonhosted.org/packages/3a/6c/69058bbcfb0164f221aa30e0cd1a250f6babb01221e27c95058c51c498ca/yarl-1.15.2-cp311-cp311-win_amd64.whl", hash = "sha256:0ccaa1bc98751fbfcf53dc8dfdb90d96e98838010fc254180dd6707a6e8bb179", size = 84492 },
+    { url = "https://files.pythonhosted.org/packages/e0/d1/17ff90e7e5b1a0b4ddad847f9ec6a214b87905e3a59d01bff9207ce2253b/yarl-1.15.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:82d5161e8cb8f36ec778fd7ac4d740415d84030f5b9ef8fe4da54784a1f46c94", size = 136721 },
+    { url = "https://files.pythonhosted.org/packages/44/50/a64ca0577aeb9507f4b672f9c833d46cf8f1e042ce2e80c11753b936457d/yarl-1.15.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:fa2bea05ff0a8fb4d8124498e00e02398f06d23cdadd0fe027d84a3f7afde31e", size = 88954 },
+    { url = "https://files.pythonhosted.org/packages/c9/0a/a30d0b02046d4088c1fd32d85d025bd70ceb55f441213dee14d503694f41/yarl-1.15.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:99e12d2bf587b44deb74e0d6170fec37adb489964dbca656ec41a7cd8f2ff178", size = 86692 },
+    { url = "https://files.pythonhosted.org/packages/06/0b/7613decb8baa26cba840d7ea2074bd3c5e27684cbcb6d06e7840d6c5226c/yarl-1.15.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:243fbbbf003754fe41b5bdf10ce1e7f80bcc70732b5b54222c124d6b4c2ab31c", size = 325762 },
+    { url = "https://files.pythonhosted.org/packages/97/f5/b8c389a58d1eb08f89341fc1bbcc23a0341f7372185a0a0704dbdadba53a/yarl-1.15.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:856b7f1a7b98a8c31823285786bd566cf06226ac4f38b3ef462f593c608a9bd6", size = 335037 },
+    { url = "https://files.pythonhosted.org/packages/cb/f9/d89b93a7bb8b66e01bf722dcc6fec15e11946e649e71414fd532b05c4d5d/yarl-1.15.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:553dad9af802a9ad1a6525e7528152a015b85fb8dbf764ebfc755c695f488367", size = 334221 },
+    { url = "https://files.pythonhosted.org/packages/10/77/1db077601998e0831a540a690dcb0f450c31f64c492e993e2eaadfbc7d31/yarl-1.15.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:30c3ff305f6e06650a761c4393666f77384f1cc6c5c0251965d6bfa5fbc88f7f", size = 330167 },
+    { url = "https://files.pythonhosted.org/packages/3b/c2/e5b7121662fd758656784fffcff2e411c593ec46dc9ec68e0859a2ffaee3/yarl-1.15.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:353665775be69bbfc6d54c8d134bfc533e332149faeddd631b0bc79df0897f46", size = 317472 },
+    { url = "https://files.pythonhosted.org/packages/c6/f3/41e366c17e50782651b192ba06a71d53500cc351547816bf1928fb043c4f/yarl-1.15.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f4fe99ce44128c71233d0d72152db31ca119711dfc5f2c82385ad611d8d7f897", size = 330896 },
+    { url = "https://files.pythonhosted.org/packages/79/a2/d72e501bc1e33e68a5a31f584fe4556ab71a50a27bfd607d023f097cc9bb/yarl-1.15.2-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:9c1e3ff4b89cdd2e1a24c214f141e848b9e0451f08d7d4963cb4108d4d798f1f", size = 328787 },
+    { url = "https://files.pythonhosted.org/packages/9d/ba/890f7e1ea17f3c247748548eee876528ceb939e44566fa7d53baee57e5aa/yarl-1.15.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:711bdfae4e699a6d4f371137cbe9e740dc958530cb920eb6f43ff9551e17cfbc", size = 332631 },
+    { url = "https://files.pythonhosted.org/packages/48/c7/27b34206fd5dfe76b2caa08bf22f9212b2d665d5bb2df8a6dd3af498dcf4/yarl-1.15.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:4388c72174868884f76affcdd3656544c426407e0043c89b684d22fb265e04a5", size = 344023 },
+    { url = "https://files.pythonhosted.org/packages/88/e7/730b130f4f02bd8b00479baf9a57fdea1dc927436ed1d6ba08fa5c36c68e/yarl-1.15.2-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:f0e1844ad47c7bd5d6fa784f1d4accc5f4168b48999303a868fe0f8597bde715", size = 352290 },
+    { url = "https://files.pythonhosted.org/packages/84/9b/e8dda28f91a0af67098cddd455e6b540d3f682dda4c0de224215a57dee4a/yarl-1.15.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a5cafb02cf097a82d74403f7e0b6b9df3ffbfe8edf9415ea816314711764a27b", size = 343742 },
+    { url = "https://files.pythonhosted.org/packages/66/47/b1c6bb85f2b66decbe189e27fcc956ab74670a068655df30ef9a2e15c379/yarl-1.15.2-cp312-cp312-win32.whl", hash = "sha256:156ececdf636143f508770bf8a3a0498de64da5abd890c7dbb42ca9e3b6c05b8", size = 78051 },
+    { url = "https://files.pythonhosted.org/packages/7d/9e/1a897e5248ec53e96e9f15b3e6928efd5e75d322c6cf666f55c1c063e5c9/yarl-1.15.2-cp312-cp312-win_amd64.whl", hash = "sha256:435aca062444a7f0c884861d2e3ea79883bd1cd19d0a381928b69ae1b85bc51d", size = 84313 },
+    { url = "https://files.pythonhosted.org/packages/46/ab/be3229898d7eb1149e6ba7fe44f873cf054d275a00b326f2a858c9ff7175/yarl-1.15.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:416f2e3beaeae81e2f7a45dc711258be5bdc79c940a9a270b266c0bec038fb84", size = 135006 },
+    { url = "https://files.pythonhosted.org/packages/10/10/b91c186b1b0e63951f80481b3e6879bb9f7179d471fe7c4440c9e900e2a3/yarl-1.15.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:173563f3696124372831007e3d4b9821746964a95968628f7075d9231ac6bb33", size = 88121 },
+    { url = "https://files.pythonhosted.org/packages/bf/1d/4ceaccf836b9591abfde775e84249b847ac4c6c14ee2dd8d15b5b3cede44/yarl-1.15.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:9ce2e0f6123a60bd1a7f5ae3b2c49b240c12c132847f17aa990b841a417598a2", size = 85967 },
+    { url = "https://files.pythonhosted.org/packages/93/bd/c924f22bdb2c5d0ca03a9e64ecc5e041aace138c2a91afff7e2f01edc3a1/yarl-1.15.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:eaea112aed589131f73d50d570a6864728bd7c0c66ef6c9154ed7b59f24da611", size = 325615 },
+    { url = "https://files.pythonhosted.org/packages/59/a5/6226accd5c01cafd57af0d249c7cf9dd12569cd9c78fbd93e8198e7a9d84/yarl-1.15.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e4ca3b9f370f218cc2a0309542cab8d0acdfd66667e7c37d04d617012485f904", size = 334945 },
+    { url = "https://files.pythonhosted.org/packages/4c/c1/cc6ccdd2bcd0ff7291602d5831754595260f8d2754642dfd34fef1791059/yarl-1.15.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:23ec1d3c31882b2a8a69c801ef58ebf7bae2553211ebbddf04235be275a38548", size = 336701 },
+    { url = "https://files.pythonhosted.org/packages/ef/ff/39a767ee249444e4b26ea998a526838238f8994c8f274befc1f94dacfb43/yarl-1.15.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:75119badf45f7183e10e348edff5a76a94dc19ba9287d94001ff05e81475967b", size = 330977 },
+    { url = "https://files.pythonhosted.org/packages/dd/ba/b1fed73f9d39e3e7be8f6786be5a2ab4399c21504c9168c3cadf6e441c2e/yarl-1.15.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:78e6fdc976ec966b99e4daa3812fac0274cc28cd2b24b0d92462e2e5ef90d368", size = 317402 },
+    { url = "https://files.pythonhosted.org/packages/82/e8/03e3ebb7f558374f29c04868b20ca484d7997f80a0a191490790a8c28058/yarl-1.15.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:8657d3f37f781d987037f9cc20bbc8b40425fa14380c87da0cb8dfce7c92d0fb", size = 331776 },
+    { url = "https://files.pythonhosted.org/packages/1f/83/90b0f4fd1ecf2602ba4ac50ad0bbc463122208f52dd13f152bbc0d8417dd/yarl-1.15.2-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:93bed8a8084544c6efe8856c362af08a23e959340c87a95687fdbe9c9f280c8b", size = 331585 },
+    { url = "https://files.pythonhosted.org/packages/c7/f6/1ed7e7f270ae5f9f1174c1f8597b29658f552fee101c26de8b2eb4ca147a/yarl-1.15.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:69d5856d526802cbda768d3e6246cd0d77450fa2a4bc2ea0ea14f0d972c2894b", size = 336395 },
+    { url = "https://files.pythonhosted.org/packages/e0/3a/4354ed8812909d9ec54a92716a53259b09e6b664209231f2ec5e75f4820d/yarl-1.15.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:ccad2800dfdff34392448c4bf834be124f10a5bc102f254521d931c1c53c455a", size = 342810 },
+    { url = "https://files.pythonhosted.org/packages/de/cc/39e55e16b1415a87f6d300064965d6cfb2ac8571e11339ccb7dada2444d9/yarl-1.15.2-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:a880372e2e5dbb9258a4e8ff43f13888039abb9dd6d515f28611c54361bc5644", size = 351441 },
+    { url = "https://files.pythonhosted.org/packages/fb/19/5cd4757079dc9d9f3de3e3831719b695f709a8ce029e70b33350c9d082a7/yarl-1.15.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:c998d0558805860503bc3a595994895ca0f7835e00668dadc673bbf7f5fbfcbe", size = 345875 },
+    { url = "https://files.pythonhosted.org/packages/83/a0/ef09b54634f73417f1ea4a746456a4372c1b044f07b26e16fa241bd2d94e/yarl-1.15.2-cp313-cp313-win32.whl", hash = "sha256:533a28754e7f7439f217550a497bb026c54072dbe16402b183fdbca2431935a9", size = 302609 },
+    { url = "https://files.pythonhosted.org/packages/20/9f/f39c37c17929d3975da84c737b96b606b68c495cc4ee86408f10523a1635/yarl-1.15.2-cp313-cp313-win_amd64.whl", hash = "sha256:5838f2b79dc8f96fdc44077c9e4e2e33d7089b10788464609df788eb97d03aad", size = 308252 },
+    { url = "https://files.pythonhosted.org/packages/46/cf/a28c494decc9c8776b0d7b729c68d26fdafefcedd8d2eab5d9cd767376b2/yarl-1.15.2-py3-none-any.whl", hash = "sha256:0d3105efab7c5c091609abacad33afff33bdff0035bece164c98bcf5a85ef90a", size = 38891 },
+]