Merge pull request #250 from specklesystems/v3-dev

dev to installer

.circleci/config.yml

@@ -1,142 +1,17 @@
 version: 2.1
 
-orbs:
-  python: circleci/python@1.3.2
-  # Using windows for builds
-  win: circleci/windows@2.4.0
-  # Upload artifacts to s3
-  aws-s3: circleci/aws-s3@2.0.0
-
+# Define the jobs we want to run for this project
 jobs:
-  build-connector: # Reusable job for basic connectors
-    executor:
-      name: win/default # comes with python 3.7.3
-      shell: cmd.exe
-    parameters:
-      slug:
-        type: string
-        default: ""
-    steps:
-      - checkout
-      - attach_workspace:
-          at: ./
-      - run: 
-          name: Install specklepy with python 3.7
-          shell: powershell.exe
-          command: |
-            $pyarr=(python --version).split(' ')[1].split('.')
-            $pyver=($pyarr[0..1] -join '.')
-            echo "using python version:" $pyver
-            $specklepy=(python patch_version.py)
-            python -m pip install --target=./modules-$pyver specklepy==$specklepy
-      - run: 
-          name: Install python 3.9 and specklepy 
-          shell: powershell.exe
-          command: |
-            choco install python --version=3.9.2
-            $pyarr=(C:\Python39\python.exe --version).split(' ')[1].split('.')
-            $pyver=($pyarr[0..1] -join '.')
-            echo "using python version:" $pyver
-            $specklepy=(python patch_version.py)
-            C:\Python39\python.exe -m pip install --target=./modules-$pyver specklepy==$specklepy
-      - run:
-          name: Patch
-          shell: powershell.exe
-          command:
-            | # If no tag, use 0.0.0.1 and don't make any YML (for testing only!)
-            $tag = if([string]::IsNullOrEmpty($env:CIRCLE_TAG)) { "0.0.1" } else { $env:CIRCLE_TAG }
-            $semver = $tag.replace("-beta","")
-            $version = "$($semver).$($env:CIRCLE_BUILD_NUM)"
-            $channel = "latest"
-            if($tag -like "*-beta") { $channel = "beta" }
-            # only create the yml if we have a tag
-            New-Item -Force "speckle-sharp-ci-tools/Installers/blender/$channel.yml" -ItemType File -Value "version: $version"
-            echo $version
-            ls
-            python patch_version.py $version
-            speckle-sharp-ci-tools\InnoSetup\ISCC.exe speckle-sharp-ci-tools\blender.iss
-      - persist_to_workspace:
-          root: ./
-          paths:
-            - speckle-sharp-ci-tools/Installers
-
-  install-specklepy: # due to ujson dep, we need to match the py version to the install
+  build:
     docker:
-      - image: "cimg/python:<<parameters.tag>>"
-    parameters:
-      tag:
-        default: "3.9"
-        type: string
+      - image: cimg/base:2023.03
     steps:
-      - checkout
-      - run:
-          name: upgrade pip and install specklepy
-          command: |
-            specklepyver=$(python patch_version.py)
-            echo installing specklepy $specklepyver
-            python -m pip install --target=./modules-<<parameters.tag>> specklepy==$specklepyver
-      - persist_to_workspace:
-          root: ./
-          paths:
-            - modules-*
-          
-  get-ci-tools: # Clones our ci tools and persists them to the workspace
-    docker:
-      - image: cimg/base:2021.01
-    steps:
-      - run: # Could not get ssh to work, so using a personal token
-          name: Clone
-          command: git clone https://$GITHUB_TOKEN@github.com/specklesystems/speckle-sharp-ci-tools.git speckle-sharp-ci-tools
-      - persist_to_workspace:
-          root: ./
-          paths:
-            - speckle-sharp-ci-tools
-
-  deploy: # Uploads all installers found to S3
-    docker:
-      - image: cimg/base:2021.01
-    steps:
-      - attach_workspace:
-          at: ./
-      - run:
-          name: List contents
-          command: ls -R speckle-sharp-ci-tools/Installers
-      - aws-s3/copy:
-          arguments: "--recursive --endpoint=https://$SPACES_REGION.digitaloceanspaces.com --acl public-read"
-          aws-access-key-id: SPACES_KEY
-          aws-region: SPACES_REGION
-          aws-secret-access-key: SPACES_SECRET
-          from: '"speckle-sharp-ci-tools/Installers/"'
-          to: s3://speckle-releases/installers/
+      - run: echo "so long and thanks for all the fish"
 
+# Orchestrate our job run sequence
 workflows:
-  main:
+  build_and_test:
+    when:
+      false
     jobs:
-      - get-ci-tools:
-          filters:
-            tags:
-              only: /.*/
-            branches:
-              only:
-                - main
-                - /ci\/.*/
-      - build-connector:
-          slug: blender
-          requires:
-            - get-ci-tools
-          filters:
-            tags:
-              only: /.*/
-            branches:
-              only:
-                - main
-                - /ci\/.*/
-      - deploy:
-          requires:
-            - get-ci-tools
-            - build-connector
-          filters:
-            tags:
-              only: /[0-9]+(\.[0-9]+)*/
-            branches:
-              ignore: /.*/ # For testing only! /ci\/.*/
+      - build

.github/workflows/close-issue.yml

@@ -1,78 +0,0 @@
-name: Update issue Status
-
-on:
-  issues:
-    types: [closed]
-
-jobs:
-  update_issue:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Get project data
-        env:
-          GITHUB_TOKEN: ${{secrets.GHPROJECT_TOKEN}}
-          ORGANIZATION: specklesystems
-          PROJECT_NUMBER: 9
-        run: |
-          gh api graphql --header 'GraphQL-Features: projects_next_graphql' -f query='
-            query($org: String!, $number: Int!) {
-              organization(login: $org){
-                projectNext(number: $number) {
-                  id
-                  fields(first:20) {
-                    nodes {
-                      id
-                      name
-                      settings
-                    }
-                  }
-                }
-              }
-            }' -f org=$ORGANIZATION -F number=$PROJECT_NUMBER > project_data.json
-
-          echo 'PROJECT_ID='$(jq '.data.organization.projectNext.id' project_data.json) >> $GITHUB_ENV
-          echo 'STATUS_FIELD_ID='$(jq '.data.organization.projectNext.fields.nodes[] | select(.name== "Status") | .id' project_data.json) >> $GITHUB_ENV
-          
-          echo "$PROJECT_ID"
-          echo "$STATUS_FIELD_ID"
-          
-          echo 'DONE_ID='$(jq '.data.organization.projectNext.fields.nodes[] | select(.name== "Status") | .settings | fromjson | .options[] | select(.name== "Done") | .id' project_data.json) >> $GITHUB_ENV
-          echo "$DONE_ID"
-
-      - name: Add Issue to project #it's already in the project, but we do this to get its node id!
-        env:
-          GITHUB_TOKEN: ${{secrets.GHPROJECT_TOKEN}}
-          ISSUE_ID: ${{ github.event.issue.node_id }}
-        run: |
-          item_id="$( gh api graphql --header 'GraphQL-Features: projects_next_graphql' -f query='
-            mutation($project:ID!, $id:ID!) {
-              addProjectNextItem(input: {projectId: $project, contentId: $id}) {
-                projectNextItem {
-                  id
-                }
-              }
-            }' -f project=$PROJECT_ID -f id=$ISSUE_ID --jq '.data.addProjectNextItem.projectNextItem.id')"
-          
-          echo 'ITEM_ID='$item_id >> $GITHUB_ENV
-          
-      - name: Update Status
-        env:
-          GITHUB_TOKEN: ${{secrets.GHPROJECT_TOKEN}}
-          ISSUE_ID: ${{ github.event.issue.node_id }}
-        run: |
-          gh api graphql --header 'GraphQL-Features: projects_next_graphql' -f query='
-            mutation($project:ID!, $status:ID!, $id:ID!, $value:String!) {
-              set_status: updateProjectNextItemField(
-                input: {
-                  projectId: $project
-                  itemId: $id
-                  fieldId: $status
-                  value: $value
-                }
-              ) {
-                projectNextItem {
-                  id
-                }
-              }
-            }' -f project=$PROJECT_ID -f status=$STATUS_FIELD_ID -f id=$ITEM_ID -f value=${{ env.DONE_ID }}
-          

.github/workflows/open-issue.yml

@@ -1,50 +0,0 @@
-name: Move new issues into Project
-
-on:
-  issues:
-    types: [opened]
-
-jobs:
-  track_issue:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Get project data
-        env:
-          GITHUB_TOKEN: ${{secrets.GHPROJECT_TOKEN}}
-          ORGANIZATION: specklesystems
-          PROJECT_NUMBER: 9
-        run: |
-          gh api graphql --header 'GraphQL-Features: projects_next_graphql' -f query='
-            query($org: String!, $number: Int!) {
-              organization(login: $org){
-                projectNext(number: $number) {
-                  id
-                  fields(first:20) {
-                    nodes {
-                      id
-                      name
-                      settings
-                    }
-                  }
-                }
-              }
-            }' -f org=$ORGANIZATION -F number=$PROJECT_NUMBER > project_data.json
-
-          echo 'PROJECT_ID='$(jq '.data.organization.projectNext.id' project_data.json) >> $GITHUB_ENV
-          echo 'STATUS_FIELD_ID='$(jq '.data.organization.projectNext.fields.nodes[] | select(.name== "Status") | .id' project_data.json) >> $GITHUB_ENV
-     
-      - name: Add Issue to project
-        env:
-          GITHUB_TOKEN: ${{secrets.GHPROJECT_TOKEN}}
-          ISSUE_ID: ${{ github.event.issue.node_id }}
-        run: |
-          item_id="$( gh api graphql --header 'GraphQL-Features: projects_next_graphql' -f query='
-            mutation($project:ID!, $id:ID!) {
-              addProjectNextItem(input: {projectId: $project, contentId: $id}) {
-                projectNextItem {
-                  id
-                }
-              }
-            }' -f project=$PROJECT_ID -f id=$ISSUE_ID --jq '.data.addProjectNextItem.projectNextItem.id')"
-          
-          echo 'ITEM_ID='$item_id >> $GITHUB_ENV

.github/workflows/pr.yml

@@ -0,0 +1,31 @@
+name: "PR workflow"
+on:
+  pull_request:
+    branches:
+      - "v3-dev"
+jobs:
+  build:
+    name: Pre-commit Checks
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install uv and set the python version
+        uses: astral-sh/setup-uv@v5
+        with:
+          python-version: "3.11"
+          enable-cache: true
+          cache-dependency-glob: "uv.lock"
+
+      - name: Install the project
+        run: uv sync --all-extras --dev
+
+      # - uses: actions/cache@v3
+      #   with:
+      #     path: ~/.cache/pre-commit/
+      #     key: ${{ hashFiles('.pre-commit-config.yaml') }}
+
+      # - name: Run pre-commit
+      #   run: uv run pre-commit run --all-files
+
+      - name: Minimize uv cache
+        run: uv cache prune --ci

.github/workflows/release.yml

@@ -0,0 +1,96 @@
+name: "Release workflow"
+on:
+  push:
+    branches: ["main", "installer-test/**"]
+    tags: ["v3.*.*"]
+
+jobs:
+  build:
+    name: Build Zip
+    runs-on: ubuntu-latest
+    env:
+      ZIP_NAME: "blender.zip"
+      SEMVER: null
+      FILE_VERSION: null
+    outputs:
+      semver: ${{ steps.set-version.outputs.semver }}
+      fileVersion: ${{ steps.set-version.outputs.fileVersion }}
+    steps:
+      - uses: actions/checkout@v4
+      - name: 🐍 Install uv and set the python version
+        uses: astral-sh/setup-uv@v5
+        with:
+          python-version: "3.11"
+          enable-cache: true
+          cache-dependency-glob: "uv.lock"
+
+      - id: set-version
+        name: Set version to output
+        run: |
+          TAG=${{ github.ref_name }}
+          if [[ "${{ github.ref }}" != refs/tags/* ]]; then
+            TAG="v3.0.99.${{ github.run_number }}"
+          fi
+          SEMVER="${TAG#v}"
+          FILE_VERSION=$(echo "$TAG" | sed -E 's/^v([0-9]+\.[0-9]+\.[0-9]+).*/\1/')
+          FILE_VERSION="$FILE_VERSION.${{ github.run_number }}"
+
+          echo "semver=$SEMVER" >> "$GITHUB_OUTPUT"
+          echo "fileVersion=$FILE_VERSION" >> "$GITHUB_OUTPUT"
+
+          echo $SEMVER
+          echo $FILE_VERSION
+
+      - name: ✏ Patch Version
+        run: python patch_version.py ${{ steps.set-version.outputs.fileVersion }}
+
+      - name: 🔄 UV Sync
+        run: uv sync --all-extras --dev
+
+      - name: 📄 Export Package Dependencies
+        run: ./export_dependencies.sh
+
+      - name: 🗃 Zip Package
+        run: zip -r ${{env.ZIP_NAME}} bpy_speckle
+
+      - name: ⬆️ Upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: output-${{ steps.set-version.outputs.semver }}
+          path: ${{env.ZIP_NAME}}
+          if-no-files-found: error
+          retention-days: 1
+          compression-level: 0 # no compression
+
+      - name: 💾 Minimize uv cache
+        run: uv cache prune --ci
+
+  deploy-installers:
+    runs-on: ubuntu-latest
+    needs: build
+    env:
+      IS_PUBLIC_RELEASE: ${{ github.ref_type == 'tag' }}
+    steps:
+      - name: 🔫 Trigger Build Installer(s)
+        uses: the-actions-org/workflow-dispatch@v4.0.0
+        with:
+          workflow: Build Installers
+          repo: specklesystems/connector-installers
+          token: ${{ secrets.CONNECTORS_GH_TOKEN }}
+          inputs: '{
+            "run_id": "${{ github.run_id }}",
+            "semver": "${{ needs.build.outputs.semver }}",
+            "file_version": "${{ needs.build.outputs.fileVersion }}",
+            "repo": "${{ github.repository }}",
+            "is_public_release": ${{ env.IS_PUBLIC_RELEASE }}
+            }'
+          ref: timestamp-sectigo
+          wait-for-completion: true
+          wait-for-completion-interval: 10s
+          wait-for-completion-timeout: 10m
+          display-workflow-run-url: true
+          display-workflow-run-url-interval: 10s
+
+      - uses: geekyeggo/delete-artifact@v5
+        with:
+          name: output-*

.gitignore

@@ -10,4 +10,8 @@ __pycache__/
 # dev
 .venv
 Installers/
-modules/
+modules/
+.tool-versions
+requirements.txt
+SEMVER
+dui3/

README.md

@@ -3,7 +3,7 @@
   Speckle | Blender
 </h1>
 <h3 align="center">
-    Connector for Blender 2.92 & 2.93
+    Connector for Blender
 </h3>
 <p align="center"><b>Speckle</b> is the data infrastructure for the AEC industry.</p><br/>
 
@@ -41,42 +41,57 @@ Give Speckle a try in no time by:
 - [![docs](https://img.shields.io/badge/docs-speckle.guide-orange?style=for-the-badge&logo=read-the-docs&logoColor=white)](https://speckle.guide/user/blender.html) reference on almost any end-user and developer functionality
 
 
-# Repo structure
+# Blender Connector
 
 The Speckle UI can be found in the 3d viewport toolbar (N), under the Speckle tab.
 
 Head to the [**📚 documentation**](https://speckle.guide/user/blender.html) for more information.
 
-## Disclaimer
-This code is WIP and as such should be used with extreme caution on non-sensitive projects.
-
 ## Installation
 
-1. Place `bpy_speckle` folder in your `addons` folder. On Windows this is typically `%APPDATA%/Blender Foundation/Blender/2.80/scripts/addons`.
-2. Go to `Edit->Preferences` (Ctrl + Alt + U)
-3. Go to the `Add-ons` tab
-4. Find and enable `SpeckleBlender 2.0` in the `Scene` category. <!-- **If enabling for the first time, expect the UI to freeze for bit while it silently installs all the dependencies.** -->
-5. The Speckle UI can be found in the 3d viewport toolbar (N), under the `Speckle` tab.
+We officially support Blender 3.3 and newer, on Windows and Mac.
+
+Please follow our installation instructions on our [connector docs](https://speckle.guide/user/blender.html#installation)
 
 ## Usage
+Once enabled in `Preferences -> Addons`,
+The Speckle connector UI can be found in the 3d viewport toolbar (N), under the `Speckle` tab.
+
 - Available user accounts are automatically detected and made available. To add user accounts use **Speckle Manager**.
-- Select the user from the dropdown list in the `Users` panel. This will populate the `Streams` list with available streams for the selected user.
-- Select a branch and commit from the dropdown menus.
-- Click on `Receive` to download the objects from the selected stream, branch, and commit. The stream objects will be loaded into a Blender Collection, named `<STREAM_NAME> [ <STREAM_BRANCH> @ <BRANCH_COMMIT> ]`. <!-- You can filter the stream by entering a query into the `Filter` field (i.e. `properties.weight>10` or `type="Mesh"`). -->
-- Click on `Open Stream in Web` to view the stream in your web browser.
+- Select the user from the dropdown list in the `Users` panel. This will populate the `Projects` list with available projects for the selected user account.
+- Select a model and version from the dropdown menus.
+- Click on `Receive` to download and convert the objects from the selected model version. The objects will be linked into a Blender Collection, named `<PROJECT_NAME> [ <MODEL_NAME> @ <VERSION_ID> ]`.
+- Click on `Open Model in Web` to view the model in your web browser.
 
-## Caveats
+## Supported Elements
 
-- Mesh objects are supported. Breps are imported as meshes using their `displayValue` data. 
-- Curves have limited support: `Polylines` are supported; `NurbsCurves` are supported, though they are not guaranteed to look the same; `Lines` are supported; `Arcs` are not supported, though they are very roughly approximated; `PolyCurves` are supported for linear / polyline segments and very approximate arc segments. These conversions are a point of focus for further development.
+The Blender Connector is still a work in progress and, as such, data sent from the Blender connector is a highly lossy exchange. Our connectors are ever evolving to facilitate more and more Speckle usecases. We welcome feedback, requests, edge cases, and contributions!
 
-## Custom properties
+The full matrix of supported Blender and Speckle types [can be found here](https://speckle.guide/user/support-tables.html#blender)
+
+
+## Additional Features
 
-- **SpeckleBlender** will look for a `texture_coordinates` property and use that to create a UV layer for the imported object. These texture coordinates are a space-separated list of floats (`[u v u v u v etc...]`) that is encoded as a base64 blob. This is subject to change as **SpeckleBlender** develops.
-- If a `renderMaterial` property is found, **SpeckleBlender** will create a material named using the sub-property `renderMaterial.name`. If a material with that name already exists in Blender, **SpeckleBlender** will just assign that existing material to the object. This allows geometry to be updated without having to re-assign and re-create materials.
-- Vertex colors are supported. The `colors` list from Speckle meshes is translated to a vertex color layer.
 - Speckle properties will be imported as custom properties on Blender objects. Nested dictionaries are expanded to individual properties by flattening their key hierarchy. I.e. `propA:{'propB': {'propC':10, 'propD':'foobar'}}` is flattened to `propA.propB.propC = 10` and `propA.propB.propD = "foobar"`.
 
+- If a `renderMaterial` property is found, **SpeckleBlender** will create a material named using the sub-property `renderMaterial.name`. If a material with that name already exists in Blender, **SpeckleBlender** will just assign that existing material to the object. This allows geometry to be updated without having to re-assign and re-create materials.
+
+- Receiving vertex colors is supported. The `colors` list from Speckle meshes is translated to a vertex color layer.
+
+- Receive/Send scripts. Allow injecting a custom python function to the receive/send process to automate any blender operations
+
+## 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 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.
+If you suspect you're seeing a conflict, Please uninstall other third party addons one at a time to identify which addon is conflicting.
+
+If you find an addon that conflicts, please try using a different version of that addon (newer or older).
+
+If you can't find a version of an addon that works, please let us know on [our forums](https://speckle.community/) the name of the addon, the versions you've tried, the version of the Speckle connector you've tried, and your OS (win/mac/linux).
 
 ## Contributing
 
@@ -91,4 +106,4 @@ The Speckle Community hangs out on [the forum](https://discourse.speckle.works),
 Unless otherwise described, the code in this repository is licensed under the Apache-2.0 License. Please note that some modules, extensions or code herein might be otherwise licensed. This is indicated either in the root of the containing folder under a different license file, or in the respective file's header. If you have any questions, don't hesitate to get in touch with us via [email](mailto:hello@speckle.systems).
 
 ## Notes
-SpeckleBlender is written and maintained by [Tom Svilans](http://tomsvilans.com) ([Github](https://github.com/tsvilans)).
+Thanks to [Tom Svilans](http://tomsvilans.com) ([Github](https://github.com/tsvilans)) for the original v1 contribution!

bpy_speckle/__init__.py

@@ -1,142 +1,146 @@
-# MIT License
-
-# Copyright (c) 2018-2021 Tom Svilans
-
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-
-# The above copyright notice and this permission notice shall be included in all
-# copies or substantial portions of the Software.
-
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
+# 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.types import WindowManager
+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]}")
 
 bl_info = {
-    "name": "SpeckleBlender 2.0",
+    "name": "Speckle Blender ",
     "author": "Speckle Systems",
-    "version": (0, 2, 0),
-    "blender": (2, 92, 0),
+    "version": (3, 999, 999),
+    "blender": (4, 2, 0),
     "location": "3d viewport toolbar (N), under the Speckle tab.",
-    "description": "The Speckle Connector using specklepy 2.0!",
+    "description": "The Speckle Connector using specklepy 3.x!",
     "warning": "This add-on is WIP and should be used with caution",
     "wiki_url": "https://github.com/specklesystems/speckle-blender",
     "category": "Scene",
 }
 
-import bpy
 
-"""
-Import PySpeckle and attempt install if not found
-"""
+# 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_workspace
+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, SPECKLE_OT_delete_model_card
+from .connector.blender_operators.select_objects import SPECKLE_OT_select_objects
+from .connector.blender_operators.add_account_button import SPECKLE_OT_add_account
+from .connector.blender_operators.load_latest_button import SPECKLE_OT_load_latest
+from .connector.blender_operators.add_project_by_url import SPECKLE_OT_add_project_by_url
+from .connector.utils.account_manager import speckle_account
+# States
+from .connector.states.speckle_state import register as register_speckle_state, unregister as unregister_speckle_state
 
-try:
-    import specklepy
-except ModuleNotFoundError as error:
-    print("Speckle not found.")
-    # TODO: Implement automatic installation of speckle and dependencies
-    # to the local Blender module folder
-
-    # from .install_dependencies import install_dependencies
-    # install_dependencies()
-
-"""
-Import SpeckleBlender classes
-"""
-
-from specklepy.api.client import SpeckleClient  # , SpeckleCache
-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
-
-"""
-Add load handler to initialize Speckle when 
-loading a Blender file
-"""
-
-
-@persistent
-def load_handler(dummy):
-    bpy.ops.speckle.users_load()
-
-
-"""
-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)
-
-
-def register():
-    from bpy.utils import register_class
-
-    for cls in speckle_classes:
-        register_class(cls)
-
-    metrics.set_host_app("Blender")
-
-    """
-    Register all new properties
-    """
-
-    bpy.types.Scene.speckle = bpy.props.PointerProperty(type=SpeckleSceneSettings)
-    bpy.types.Collection.speckle = bpy.props.PointerProperty(
-        type=SpeckleCollectionSettings
+def invoke_window_manager_properties():
+    # Accounts
+    WindowManager.speckle_accounts = bpy.props.CollectionProperty(
+        type = speckle_account
     )
-    bpy.types.Object.speckle = bpy.props.PointerProperty(type=SpeckleObjectSettings)
+    WindowManager.selected_account_id = bpy.props.StringProperty()
+    # Workspaces
+    WindowManager.speckle_workspaces = bpy.props.CollectionProperty(
+        type = speckle_workspace
+    )
+    WindowManager.selected_workspace_id = bpy.props.StringProperty()
+    # Projects
+    WindowManager.speckle_projects = bpy.props.CollectionProperty(
+                type=speckle_project
+            )
+    WindowManager.selected_project_id = bpy.props.StringProperty()
+    WindowManager.selected_project_name = bpy.props.StringProperty()        
+    # Models
+    WindowManager.speckle_models = bpy.props.CollectionProperty(
+                type=speckle_model
+            )
+    WindowManager.selected_model_id = bpy.props.StringProperty()
+    WindowManager.selected_model_name = bpy.props.StringProperty()
+    # Versions
+    WindowManager.speckle_versions = bpy.props.CollectionProperty(
+            type=speckle_version
+        )
+    WindowManager.selected_version_id = bpy.props.StringProperty()
+    WindowManager.selected_version_load_option = bpy.props.StringProperty()
 
-    """
-    Add callbacks
-    """
+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)
 
-    # 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
-    #     ))
+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_workspace,
+    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_delete_model_card,
+    SPECKLE_OT_select_objects,
+    SPECKLE_OT_add_account,
+    SPECKLE_OT_load_latest,
+    SPECKLE_OT_add_project_by_url,
+    speckle_account)
+
+@bpy.app.handlers.persistent
+def load_handler(dummy):
+    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():
+    icons.load_icons()
+
+    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)
 
+    invoke_window_manager_properties()
 
 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_manifest.toml

@@ -0,0 +1,74 @@
+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 = "AEC SYSTEMS LTD"
+# 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 = [
+  "2022-2025 AEC SYSTEMS LTD",
+]
+
+# 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 = ["files", "network", "clipboard"]
+
+
+# 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 = "Speckle Server comms, and PyPI for dependency management"
+files = "Data caching, Account Management, Python dependency management"
+clipboard = "Copy and paste URLs and Names (UI)"
+
+# 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__/",
+  "/.vscode",
+  "*.code-workspace",
+]

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,14 +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))
-    # print('>>> Update')

bpy_speckle/clients.py

@@ -1,4 +0,0 @@
-"""
-Permanent handle on all user clients
-"""
-speckle_clients = []

bpy_speckle/connector/blender_operators/__init__.py

@@ -0,0 +1,9 @@
+from ..blender_operators.load_button import SPECKLE_OT_load # noqa: F401
+from ..blender_operators.load_latest_button import SPECKLE_OT_load_latest # 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
+    SPECKLE_OT_view_in_browser, #noqa: F401
+    SPECKLE_OT_view_model_versions, #noqa: F401
+    SPECKLE_OT_delete_model_card #noqa: F401
+)

bpy_speckle/connector/blender_operators/add_account_button.py

@@ -0,0 +1,38 @@
+import bpy
+import webbrowser
+from bpy.types import Event, Context
+
+class SPECKLE_OT_add_account(bpy.types.Operator):
+    """Operator for adding a new Speckle account.
+    """
+    bl_idname = "speckle.add_account"
+    bl_label = "Add New Account"
+    bl_description = "Add a new account"
+    
+    server_url: bpy.props.StringProperty(  # type: ignore
+        name="Server URL",
+        description="Speckle server URL to connect to",
+        default="https://app.speckle.systems"
+    )
+    
+    def invoke(self, context: Context, event: Event) -> set[str]:
+        return context.window_manager.invoke_props_dialog(self)
+    
+    def draw(self, context: Context):
+        layout = self.layout
+        # Server URL textbox
+        layout.prop(self, "server_url", text="Server URL")
+    
+    def execute(self, context: Context) -> set[str]:
+        # Logic to handle sign in
+        api_url = "http://localhost:29364"
+        url = f"{api_url}/auth/add-account?serverUrl={self.server_url}"
+        webbrowser.open(url)
+        self.report({'INFO'}, f"Adding account from {self.server_url}: {url}")
+        
+        # Force redraw
+        context.window.screen = context.window.screen
+        context.area.tag_redraw()
+
+            
+        return {'FINISHED'}

bpy_speckle/connector/blender_operators/add_project_by_url.py

@@ -0,0 +1,109 @@
+import bpy
+from bpy.types import Context, Event, UILayout, WindowManager
+from specklepy.api.wrapper import StreamWrapper
+from typing import Tuple
+
+from ...connector.utils.version_manager import get_latest_version
+
+class SPECKLE_OT_add_project_by_url(bpy.types.Operator):
+    """
+    operator for adding a Speckle project by URL
+    """
+
+    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}")
+
+        wm = context.window_manager
+        try:
+            wrapper = StreamWrapper(self.url)
+        except Exception as e:
+            self.report({"ERROR"}, f"Failed to process URL: {str(e)}")
+            return {"CANCELLED"}
+        # Get model details from the wrapper
+        account_id, project_id, project_name, model_id, model_name, version_id, load_option = get_model_details_by_wrapper(wrapper)
+
+        wm.selected_account_id = account_id
+
+        if project_id:
+            wm.selected_project_id = project_id
+            wm.selected_project_name = project_name
+            if model_id:
+                wm.selected_model_id = model_id
+                wm.selected_model_name = model_name
+                if version_id:
+                    wm.selected_version_id = version_id
+            wm.selected_version_id = version_id
+            wm.selected_version_load_option = load_option
+        context.window.screen = context.window.screen
+        context.area.tag_redraw()
+        return {"FINISHED"}
+
+    def invoke(self, context: Context, event: Event) -> set[str]:
+        # Ensure all required properties exist in WindowManager
+        if not hasattr(WindowManager, "selected_account_id"):
+            WindowManager.selected_account_id = bpy.props.StringProperty()
+
+        if not hasattr(WindowManager, "selected_project_id"):
+            WindowManager.selected_project_id = bpy.props.StringProperty(
+                name="Selected Project ID"
+            )
+        if not hasattr(WindowManager, "selected_project_name"):
+            WindowManager.selected_project_name = bpy.props.StringProperty(
+                name="Selected Project Name"
+            )
+
+        if not hasattr(WindowManager, "selected_model_id"):
+            WindowManager.selected_model_id = bpy.props.StringProperty(
+                name="Selected Model ID"
+            )
+        if not hasattr(WindowManager, "selected_model_name"):
+            WindowManager.selected_model_name = bpy.props.StringProperty(
+                name="Selected Model Name"
+            )
+
+        if not hasattr(WindowManager, "selected_version_id"):
+            WindowManager.selected_version_id = bpy.props.StringProperty(
+                name="Selected Version ID"
+            )
+
+        if not hasattr(WindowManager, "selected_version_load_option"):
+            WindowManager.selected_version_load_option = bpy.props.StringProperty(
+                name="Selected Version Load Option"
+            )
+
+        return context.window_manager.invoke_props_dialog(self)
+
+    def draw(self, context: Context) -> None:
+        layout: UILayout = self.layout
+        layout.prop(self, "url", text="")
+
+def register() -> None:
+    bpy.utils.register_class(SPECKLE_OT_add_project_by_url)
+
+def unregister() -> None:
+    bpy.utils.unregister_class(SPECKLE_OT_add_project_by_url)
+
+def get_model_details_by_wrapper(wrapper: StreamWrapper) -> Tuple[str, str, str, str, str, str]:
+    client = wrapper.get_client()
+    client.authenticate_with_account(wrapper.get_account())
+    account_id, project_id, project_name, model_id, model_name, version_id, load_option = "", "", "", "", "", "", ""
+    account_id = wrapper.get_account().id
+    if wrapper.stream_id:
+        project_id = wrapper.stream_id
+        project_name = client.project.get(project_id).name
+    if wrapper.model_id:
+        model_id = wrapper.model_id
+        model = client.model.get(model_id, project_id)
+        model_name = model.name
+        load_option = "LATEST" if not wrapper.commit_id else "SPECIFIC"
+        version_id = wrapper.commit_id if wrapper.commit_id else client.version.get_versions(wrapper.model_id, wrapper.stream_id, limit = 1).items[0].id
+    return (account_id, project_id, project_name, model_id, model_name, version_id, load_option)

bpy_speckle/connector/blender_operators/load_button.py

@@ -0,0 +1,42 @@
+import bpy
+from typing import Set
+from bpy.types import Context
+from ..operations.load_operation import load_operation
+from ..utils.account_manager import get_server_url_by_account_id
+
+
+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]:
+        return self.execute(context)
+
+    def execute(self, context: Context) -> Set[str]:
+        wm = context.window_manager
+        model_card = context.scene.speckle_state.model_cards.add()
+        model_card.account_id = wm.selected_account_id
+        model_card.server_url = get_server_url_by_account_id(wm.selected_account_id)
+        model_card.project_id = wm.selected_project_id
+        model_card.project_name = wm.selected_project_name
+        model_card.model_id = wm.selected_model_id
+        model_card.model_name = wm.selected_model_name
+        model_card.is_publish = False
+        model_card.load_option = wm.selected_version_load_option
+        model_card.version_id = wm.selected_version_id
+        model_card.collection_name = f"{wm.selected_model_name} - {wm.selected_version_id[:8]}"
+
+        # Load selected model version
+        load_operation(context)
+
+        # Clear selected model details from Window Manager
+        wm.selected_account_id = ""
+        wm.selected_project_id = ""
+        wm.selected_project_name = ""
+        wm.selected_model_id = ""
+        wm.selected_model_name = ""
+        wm.selected_version_load_option = ""
+        wm.selected_version_id = ""
+
+        return {"FINISHED"}

bpy_speckle/connector/blender_operators/load_latest_button.py

@@ -0,0 +1,81 @@
+import bpy
+from typing import Set
+from bpy.types import Context
+from ..utils.version_manager import get_latest_version
+from ..operations.load_operation import load_operation
+
+
+class SPECKLE_OT_load_latest(bpy.types.Operator):
+    bl_idname = "speckle.load_latest"
+    bl_label = "Load Latest from Speckle"
+    bl_description = "Load the latest version from Speckle"
+
+    model_card_id: bpy.props.StringProperty(name="Model Card ID", default="")  # type: ignore
+
+    def execute(self, context: Context) -> Set[str]:
+        wm = context.window_manager
+
+        # Get the model card
+        model_card = context.scene.speckle_state.get_model_card_by_id(self.model_card_id)
+
+        # Check if load_option is set to "LATEST"
+        if model_card.load_option != "LATEST":
+            # Do nothing if load_option is not "LATEST"
+            return {"FINISHED"}
+        
+        # Get the latest version from Speckle
+        latest_version_id, message, timestamp = get_latest_version(
+            model_card.account_id, 
+            model_card.project_id, 
+            model_card.model_id
+        )
+        # Throw error if latest version is not found
+        if not latest_version_id:
+            self.report({"ERROR"}, "Failed to get latest version")
+            return {"CANCELLED"}
+        
+        # Check if the collection exists and delete it if it does
+        collection = bpy.data.collections.get(model_card.collection_name)
+        
+        # Update the model card with the latest version ID
+        original_version_id = model_card.version_id
+        if latest_version_id == original_version_id:
+            self.report({"INFO"}, "Latest version is already loaded")
+            return {"FINISHED"}
+
+        if collection:
+            # Remove the collection
+            bpy.data.collections.remove(collection)
+            self.report({"INFO"}, f"Deleted existing collection: {model_card.collection_name}")
+        # overwrite version id of the model card stored in the doc
+        model_card.version_id = latest_version_id
+        
+        # overwrite version id store in wm
+        # Set Window Manager properties 
+        wm.selected_account_id = model_card.account_id
+        wm.selected_project_id = model_card.project_id
+        wm.selected_model_name = model_card.model_name
+        wm.selected_version_id = latest_version_id
+        
+        # Load the latest version
+        try:
+            load_operation(context)
+            self.report(
+                {"INFO"}, 
+                f"Loaded latest version: {latest_version_id[:8]} (was: {original_version_id[:8]})"
+            )
+            # update collection name in model card
+            model_card.collection_name = f"{model_card.model_name} - {latest_version_id[:8]}"
+        except Exception as e:
+            # Restore the original version ID if loading fails
+            model_card.version_id = original_version_id
+            self.report({"ERROR"}, f"Failed to load latest version: {str(e)}")
+            return {"CANCELLED"}
+        
+        # Clear selected model details from Window Manager
+        wm.selected_account_id = ""
+        wm.selected_project_id = ""
+        wm.selected_version_id = ""
+        wm.selected_model_name = ""
+        
+        return {"FINISHED"}

bpy_speckle/connector/blender_operators/model_card_settings.py

@@ -0,0 +1,127 @@
+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
+    """
+
+    bl_idname = "speckle.model_card_settings"
+    bl_label = "Model Card Settings"
+    bl_description = "Settings for the model card"
+    model_card_id: bpy.props.StringProperty(name="Model Card ID", default="")  # type:ignore
+
+    def execute(self, context: Context) -> Set[str]:
+        return {"FINISHED"}
+
+    def draw(self, context: Context) -> None:
+        layout: UILayout = self.layout
+        layout.operator(
+            "speckle.view_in_browser", text="View in Browser"
+        ).model_card_id = self.model_card_id
+        layout.operator(
+            "speckle.view_model_versions", text="View Model Versions"
+        ).model_card_id = self.model_card_id
+        layout.separator()
+        row = layout.row()
+        # add a button for deleting the model card
+        row.alert = True
+        delete_op = row.operator(
+            "speckle.delete_model_card", text="Delete Model Card", icon="TRASH"
+        )
+        delete_op.model_card_id = self.model_card_id
+
+    def invoke(self, context: Context, event: Event) -> Set[str]:
+        wm = context.window_manager
+        return wm.invoke_popup(self)
+
+
+class SPECKLE_OT_view_in_browser(bpy.types.Operator):
+    """
+    opens the current model in the Speckle web viewer
+    """
+
+    bl_idname = "speckle.view_in_browser"
+    bl_label = "View in Browser"
+    bl_description = "View the model in the browser"
+
+    model_card_id: bpy.props.StringProperty()  # type: ignore
+
+    def execute(self, context: Context) -> Set[str]:
+        model_card = context.scene.speckle_state.get_model_card_by_id(
+            self.model_card_id
+        )
+        if model_card is None:
+            self.report({"ERROR"}, "Model card not found")
+            return {"CANCELLED"}
+
+        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"}
+
+
+class SPECKLE_OT_view_model_versions(bpy.types.Operator):
+    """
+    opens the model's version history 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_id: bpy.props.StringProperty()  # type: ignore
+
+    def execute(self, context: Context) -> Set[str]:
+        model_card = context.scene.speckle_state.get_model_card_by_id(
+            self.model_card_id
+        )
+        if model_card is None:
+            self.report({"ERROR"}, "Model card not found")
+            return {"CANCELLED"}
+
+        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"}
+
+
+class SPECKLE_OT_delete_model_card(bpy.types.Operator):
+    """
+    deletes a Speckle model card from the Blender UI
+    """
+
+    bl_idname = "speckle.delete_model_card"
+    bl_label = "Delete Model Card"
+    bl_description = "Delete this model card"
+
+    model_card_id: bpy.props.StringProperty()  # type: ignore
+
+    def execute(self, context: Context) -> Set[str]:
+        model_card = context.scene.speckle_state.get_model_card_by_id(
+            self.model_card_id
+        )
+        if model_card is None:
+            self.report({"ERROR"}, "Model card not found")
+            return {"CANCELLED"}
+
+        model_name = model_card.model_name
+
+        # find the index of the model card and remove it
+        for i, card in enumerate(context.scene.speckle_state.model_cards):
+            if card.get_model_card_id() == self.model_card_id:
+                context.scene.speckle_state.model_cards.remove(i)
+                break
+
+        self.report({"INFO"}, f"Model card '{model_name}' has been deleted")
+        context.window.screen = context.window.screen
+
+        context.area.tag_redraw()
+        return {"FINISHED"}
+
+    def invoke(self, context: Context, event: Event) -> Set[str]:
+        return self.execute(context)

bpy_speckle/connector/blender_operators/publish_button.py

@@ -0,0 +1,20 @@
+import bpy
+from bpy.types import Context
+from bpy.types import Event
+from typing import Set
+
+
+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]:
+        return self.execute(context)
+
+    def execute(self, context: Context) -> Set[str]:
+        context.scene.speckle_state.ui_mode = "PUBLISH"
+
+        bpy.ops.speckle.project_selection_dialog("INVOKE_DEFAULT")
+        return {"FINISHED"}

bpy_speckle/connector/blender_operators/select_objects.py

@@ -0,0 +1,53 @@
+import bpy
+from bpy.types import Operator
+from bpy.props import StringProperty
+
+
+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_id: StringProperty(
+        name="Model Card ID", description="ID of the model card", default=""
+    )  # type: ignore
+
+    def execute(self, context):
+        model_card = context.scene.speckle_state.get_model_card_by_id(
+            self.model_card_id
+        )
+        if model_card is None:
+            self.report({"ERROR"}, "Model card not found")
+            return {"CANCELLED"}
+
+        collection_name = model_card.collection_name
+
+        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)
+
+        selected = context.selected_objects
+        if selected:
+            context.view_layer.objects.active = selected[0]
+
+            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 @@
+from ..operations.load_operation import load_operation  # noqa: F401

bpy_speckle/connector/operations/load_operation.py

@@ -0,0 +1,270 @@
+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.utils import find_object_by_id
+from ...converter.to_native import (
+    convert_to_native,
+    render_material_proxy_to_native,
+    instance_definition_proxy_to_native,
+    find_instance_definitions,
+)
+
+
+def load_operation(context: Context) -> None:
+    """
+    load objects from Speckle and maintain hierarchy.
+    """
+    wm = context.window_manager
+
+    # get account
+    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
+
+    print(f"Using account: {account.userInfo.email}")
+
+    # receive the data
+    client = SpeckleClient(host=account.serverInfo.url)
+    client.authenticate_with_account(account)
+
+    transport = ServerTransport(stream_id=wm.selected_project_id, client=client)
+
+    version = client.version.get(wm.selected_version_id, wm.selected_project_id)
+    obj_id = version.referenced_object
+
+    version_data = operations.receive(obj_id, transport)
+
+    # Create material mapping first
+    material_mapping = render_material_proxy_to_native(version_data)
+
+    definition_collections, definition_objects = instance_definition_proxy_to_native(
+        version_data, material_mapping
+    )
+
+    definitions_root_collection = None
+    if definition_collections:
+        definitions_root_collection = bpy.data.collections.new("InstanceDefinitions")
+
+        for collection in definition_collections.values():
+            definitions_root_collection.children.link(collection)
+
+    definition_object_ids = set()
+    for definition in find_instance_definitions(version_data).values():
+        definition_object_ids.update(definition.objects)
+        for obj_id in definition.objects:
+            found_obj = find_object_by_id(version_data, obj_id)
+            if found_obj:
+                if hasattr(found_obj, "id"):
+                    definition_object_ids.add(found_obj.id)
+                if hasattr(found_obj, "applicationId"):
+                    definition_object_ids.add(found_obj.applicationId)
+
+    traversal_function = create_default_traversal_function()
+
+    root_collection_name = f"{wm.selected_model_name} - {wm.selected_version_id[:8]}"
+    root_collection = bpy.data.collections.new(root_collection_name)
+    context.scene.collection.children.link(root_collection)
+
+    context.window_manager.progress_begin(0, 100)
+
+    converted_objects = definition_objects.copy()
+
+    created_collections = {}
+    created_collections[root_collection_name] = root_collection
+
+    collection_hierarchy = {}
+    all_objects = {}
+
+    speckle_root_id = None
+
+    for traversal_item in traversal_function.traverse(version_data):
+        speckle_obj = traversal_item.current
+
+        # Skip objects that are part of instance definitions
+        if speckle_obj.id in definition_object_ids or (
+            hasattr(speckle_obj, "applicationId")
+            and speckle_obj.applicationId in definition_object_ids
+        ):
+            continue
+
+        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):
+            if not parent_ascendants and speckle_root_id is None:
+                speckle_root_id = speckle_obj.id
+
+            collection_name = getattr(
+                speckle_obj, "name", f"Collection_{speckle_obj.id[:8]}"
+            )
+
+            parent_id = None
+            for parent in parent_ascendants:
+                if isinstance(parent, SCollection) and hasattr(parent, "id"):
+                    parent_id = parent.id
+                    break
+
+            collection_hierarchy[speckle_obj.id] = {
+                "id": speckle_obj.id,
+                "name": collection_name,
+                "parent_id": parent_id,
+                "blender_collection": None,
+                "full_path": [collection_name],
+            }
+
+            if parent_id in collection_hierarchy:
+                collection_hierarchy[speckle_obj.id]["full_path"] = (
+                    collection_hierarchy[parent_id]["full_path"] + [collection_name]
+                )
+
+        else:
+            pass
+
+    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)
+
+    sorted_collections = sorted(
+        collection_hierarchy.keys(),
+        key=lambda coll_id: (
+            get_collection_depth(coll_id),
+            collection_hierarchy[coll_id]["name"],
+        ),
+    )
+
+    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:
+        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"]
+
+        collection_key = tuple(full_path)
+
+        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"]
+
+        if collection_key in created_collections:
+            print(f"Collection already exists: {coll_name}")
+            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
+
+        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
+
+        if isinstance(speckle_obj, SCollection):
+            continue
+
+        if not hasattr(speckle_obj, "id"):
+            print("Skipping object without ID")
+            continue
+
+        # Skip objects that are part of instance definitions
+        if speckle_obj.id in definition_object_ids or (
+            hasattr(speckle_obj, "applicationId")
+            and speckle_obj.applicationId in definition_object_ids
+        ):
+            continue
+
+        if speckle_obj.id in converted_objects:
+            continue
+
+        try:
+            target_collection = root_collection
+            ascendants = list(get_ascendants(traversal_item))
+
+            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
+
+            blender_obj = convert_to_native(
+                speckle_obj,
+                material_mapping,
+                definition_collections=definition_collections,
+                root_collection=target_collection,
+            )
+
+            if blender_obj is None:
+                continue
+
+            converted_objects[speckle_obj.id] = blender_obj
+            if hasattr(speckle_obj, "applicationId"):
+                converted_objects[speckle_obj.applicationId] = blender_obj
+
+            if not isinstance(blender_obj, bpy.types.Collection):
+                try:
+                    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()
+
+        conversion_count += 1
+        if conversion_count % 10 == 0:
+            context.window_manager.progress_update(min(conversion_count, 100))
+
+    context.window_manager.progress_end()
+
+    for area in context.screen.areas:
+        if area.type == "OUTLINER":
+            area.tag_redraw()
+
+    print(f"\nLoad process completed. Imported {len(converted_objects)} objects.")

bpy_speckle/connector/states/speckle_state.py

@@ -0,0 +1,32 @@
+import bpy
+from bpy.props import CollectionProperty, StringProperty
+from bpy.types import PropertyGroup
+from typing import Optional
+
+from ..ui.model_card import speckle_model_card
+
+
+class SpeckleState(PropertyGroup):
+    """
+    manages the state of the Speckle addon in Blender
+    """
+
+    ui_mode: StringProperty(name="UI Mode", default="NONE")  # type: ignore
+    model_cards: CollectionProperty(type=speckle_model_card)  # type: ignore
+
+    def get_model_card_by_id(self, model_card_id: str) -> Optional[speckle_model_card]:
+        """Find a model card by its ID."""
+        for model_card in self.model_cards:
+            if model_card.get_model_card_id() == model_card_id:
+                return model_card
+        return None
+
+
+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,131 @@
+import bpy
+from bpy.types import UILayout, Context
+from .icons import get_icon
+
+
+class SPECKLE_PT_main_panel(bpy.types.Panel):
+    """
+    main panel for the Speckle addon.
+    """
+
+    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.")
+
+        layout.separator()
+
+        wm = context.window_manager
+        project_selected = bool(getattr(wm, "selected_project_name", None))
+        model_selected = bool(getattr(wm, "selected_model_name", None))
+        version_selected = bool(getattr(wm, "selected_version_id", None))
+
+        # select Project button
+        row = layout.row()
+        project_name = getattr(wm, "selected_project_name", "")
+        project_button_text = project_name if project_selected else "Select Project"
+        project_button_icon = "CHECKMARK" if project_selected else "PLUS"
+        row.operator(
+            "speckle.project_selection_dialog",
+            text=project_button_text,
+            icon=project_button_icon,
+        )
+
+        # select Model button
+        row = layout.row()
+        model_name = getattr(wm, "selected_model_name", "")
+        model_button_text = model_name if model_selected else "Select Model"
+        model_button_icon = "CHECKMARK" if model_selected else "PLUS"
+        row.enabled = project_selected
+        row.operator(
+            "speckle.model_selection_dialog",
+            text=model_button_text,
+            icon=model_button_icon,
+        )
+
+        # select Version button
+        row = layout.row()
+        version_id = getattr(wm, "selected_version_id", "")
+        load_option = getattr(wm, "selected_version_load_option", "")
+        if load_option == "LATEST":
+            version_button_text = "Latest"
+        elif load_option == "SPECIFIC":
+            version_button_text = version_id
+        else:
+            version_button_text = "Select Version"
+
+        version_button_icon = "CHECKMARK" if version_selected else "PLUS"
+        row.enabled = project_selected and model_selected
+        row.operator(
+            "speckle.version_selection_dialog",
+            text=version_button_text,
+            icon=version_button_icon,
+        )
+
+        # load button
+        row = layout.row()
+        row.enabled = project_selected and model_selected and version_selected
+        row.operator("speckle.load", text="Load Model", icon="IMPORT")
+
+        layout.separator()
+
+        # group model cards by project name
+        project_groups = {}
+        for model_card in context.scene.speckle_state.model_cards:
+            project_name = (
+                model_card.project_name if model_card.project_name else "No Project"
+            )
+            if project_name not in project_groups:
+                project_groups[project_name] = []
+            project_groups[project_name].append(model_card)
+
+        for project_name, model_cards in project_groups.items():
+            project_box = layout.box()
+            project_row = project_box.row()
+            project_row.label(text=f"Project: {project_name}", icon="TRIA_RIGHT")
+
+            for model_card in model_cards:
+                box: UILayout = project_box.box()
+                row: UILayout = box.row()
+                icon: str = "EXPORT" if model_card.is_publish else "IMPORT"
+                
+                # Load latest button in the model card
+                row.operator("speckle.load_latest", text="", icon=icon).model_card_id = model_card.get_model_card_id()
+                row.label(text=f"{model_card.model_name}")
+                
+                # Select button in the model card
+                select_op = row.operator(
+                    "speckle.select_objects", text="", icon="RESTRICT_SELECT_OFF"
+                )
+                select_op.model_card_id = model_card.get_model_card_id()
+                
+                # Settings button in the model card
+                row.operator(
+                    "speckle.model_card_settings", text="", icon="PREFERENCES"
+                ).model_card_id = model_card.get_model_card_id()
+                row: UILayout = box.row()
+                if model_card.is_publish:
+                    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:
+                    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,87 @@
+import bpy
+from typing import Dict, Any
+
+
+class speckle_model_card(bpy.types.PropertyGroup):
+    """
+    represents a Speckle model card in the Blender UI
+    """
+
+    account_id: bpy.props.StringProperty(
+        name="Account ID", description="ID of the account", default=""
+    )  # type: ignore
+    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
+    collection_name: bpy.props.StringProperty(
+        name="Collection Name", description="Name of the collection", default=""
+    )  # type: ignore
+
+    def get_model_card_id(self) -> str:
+        if not self.project_id or not self.model_id:
+            raise ValueError(
+                "Project ID and Model ID are required to generate a model card ID."
+            )
+        return self.project_id + "-" + self.model_id
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        converts the model card to a dictionary representation
+        """
+        return {
+            "account_id": self.account_id,
+            "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,
+            "collection_name": self.collection_name,
+        }
+
+    @classmethod
+    def from_dict(cls, data):
+        """
+        creates a new model card instance from a dictionary
+        """
+        item = cls()
+        item.account_id = data["account_id"]
+        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"]
+        item.collection_name = data["collection_name"]

bpy_speckle/connector/ui/model_selection_dialog.py

@@ -0,0 +1,137 @@
+import bpy
+from bpy.types import UILayout, Context, PropertyGroup, Event
+from ..utils.model_manager import get_models_for_project
+from ..utils.version_manager import get_latest_version
+
+
+class speckle_model(bpy.types.PropertyGroup):
+    """
+    PropertyGroup for storing model information
+    """
+
+    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
+    """
+
+    def draw_item(
+        self,
+        context: Context,
+        layout: UILayout,
+        data: PropertyGroup,
+        item: PropertyGroup,
+        icon: str,
+        active_data: PropertyGroup,
+        active_propname: str,
+    ) -> None:
+        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)
+
+        elif self.layout_type == "GRID":
+            layout.alignment = "CENTER"
+            layout.label(text=item.name)
+
+
+class SPECKLE_OT_model_selection_dialog(bpy.types.Operator):
+    """
+    operator for displaying and handling the model selection dialog
+    """
+
+    bl_idname = "speckle.model_selection_dialog"
+    bl_label = "Select Model"
+
+    def update_models_list(self, context: Context) -> None:
+        wm = context.window_manager
+
+        wm.speckle_models.clear()
+
+        search = self.search_query if self.search_query.strip() else None
+        models = get_models_for_project(
+            wm.selected_account_id, wm.selected_project_id, search=search
+        )
+
+        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,
+    )
+
+    model_index: bpy.props.IntProperty(name="Model Index", default=0)  # type: ignore
+
+    def execute(self, context: Context) -> set[str]:
+        wm = context.window_manager
+        if 0 <= self.model_index < len(wm.speckle_models):
+            selected_model = wm.speckle_models[self.model_index]
+
+            wm.selected_model_id = selected_model.id
+            wm.selected_model_name = selected_model.name
+
+            latest_version = get_latest_version(
+                account_id=wm.selected_account_id,
+                project_id=wm.selected_project_id,
+                model_id=wm.selected_model_id,
+            )
+            if latest_version:
+                wm.selected_version_load_option = "LATEST"
+                wm.selected_version_id = latest_version[0]
+
+            print(f"Selected model: {selected_model.name} ({selected_model.id})")
+
+            context.area.tag_redraw()
+        return {"FINISHED"}
+
+    def invoke(self, context: Context, event: Event) -> set[str]:
+        self.update_models_list(context)
+
+        return context.window_manager.invoke_props_dialog(self)
+
+    def draw(self, context: Context) -> None:
+        layout: UILayout = self.layout
+        wm = context.window_manager
+        layout.label(text=f"Project: {wm.selected_project_name}")
+
+        row = layout.row(align=True)
+        row.prop(self, "search_query", icon="VIEWZOOM", text="")
+
+        layout.template_list(
+            "SPECKLE_UL_models_list",
+            "",
+            context.window_manager,
+            "speckle_models",
+            self,
+            "model_index",
+        )
+
+        layout.separator()
+
+
+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:
+    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/project_selection_dialog.py

@@ -0,0 +1,261 @@
+import bpy
+from bpy.types import UILayout, Context, PropertyGroup, Event
+from typing import List, Tuple
+from ..utils.account_manager import get_account_enum_items, speckle_account, get_workspaces, speckle_workspace, get_account_from_id
+from ..utils.project_manager import get_projects_for_account
+
+def get_accounts_callback(self, context):
+    """Callback to dynamically fetch account enum items.
+    """
+    wm = context.window_manager
+    return [
+        (
+            account.id,
+            f"{account.user_name} - {account.user_email} - {account.server_url}",
+            ""
+        )
+        for account in wm.speckle_accounts
+    ]
+
+def get_workspaces_callback(self, context):
+    """
+    Callback to dynamically fetch workspace enum items.
+    """
+    wm = context.window_manager
+    return [
+        (
+            workspace.id,
+            workspace.name,
+            "",
+            "WORKSPACE",
+            i
+        )
+        for i, workspace in enumerate(wm.speckle_workspaces)
+    ]
+
+class speckle_project(bpy.types.PropertyGroup):
+    """
+    PropertyGroup for storing project information
+    """
+
+    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
+    """
+
+    def draw_item(
+        self,
+        context: Context,
+        layout: UILayout,
+        data: PropertyGroup,
+        item: PropertyGroup,
+        icon: str,
+        active_data: PropertyGroup,
+        active_propname: str,
+    ) -> None:
+        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.5)
+            right_split.label(text=item.role)
+            right_split.label(text=item.updated)
+
+        # 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
+    """
+
+    bl_idname = "speckle.project_selection_dialog"
+    bl_label = "Select Project"
+
+    def update_workspaces_and_projects_list(self, context: Context) -> None:
+        wm = context.window_manager
+        wm.selected_account_id = self.accounts
+        wm.speckle_workspaces.clear()
+        workspaces = get_workspaces(self.accounts)
+        for id, name in workspaces:
+            workspace: speckle_workspace = wm.speckle_workspaces.add()
+            workspace.id = id
+            workspace.name = name
+        print("Updated Workspaces List!")
+
+        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, workspace_id=self.workspaces
+        )
+
+        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
+        print("Updated Projects List!")
+
+        return None
+
+    def update_projects_list(self, context: Context) -> None:
+        """
+        updates the list of projects based on the selected account and search query
+        """
+        wm = context.window_manager
+
+        wm.selected_account_id = self.accounts
+        wm.selected_workspace_id = self.workspaces
+
+        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, workspace_id=self.workspaces
+        )
+
+        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
+        print("Updated Projects List!")
+        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_accounts_callback,
+        update=update_workspaces_and_projects_list,
+    )
+
+    workspaces: bpy.props.EnumProperty(  # type: ignore
+        name="Workspace",
+        description="Selected workspace to filter projects by",
+        items=get_workspaces_callback,
+        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]
+
+            wm.selected_project_id = selected_project.id
+            wm.selected_project_name = selected_project.name
+
+            print(f"Selected project: {selected_project.name} ({selected_project.id})")
+
+            context.area.tag_redraw()
+        return {"FINISHED"}
+
+    def invoke(self, context: Context, event: Event) -> set[str]:
+        wm = context.window_manager
+
+        # Clear existing accounts and projects
+        wm.speckle_accounts.clear()
+        wm.speckle_projects.clear()
+        wm.speckle_workspaces.clear()
+
+        # Fetch accounts
+        for id, user_name, server_url, user_email in get_account_enum_items():
+            account: speckle_account = wm.speckle_accounts.add()
+            account.id = id
+            account.user_name = user_name
+            account.server_url = server_url
+            account.user_email = user_email
+
+        selected_account_id = self.accounts
+        wm.selected_account_id = selected_account_id
+
+        # Fetch workspaces from server
+        for id, name in get_workspaces(selected_account_id):
+            workspace: speckle_workspace = wm.speckle_workspaces.add()
+            workspace.id = id
+            workspace.name = name
+        selected_workspace_id = self.workspaces
+        wm.selected_workspace_id = selected_workspace_id
+
+        # Fetch projects from server
+        projects: List[Tuple[str, str, str, str]] = get_projects_for_account(
+            selected_account_id, workspace_id=selected_workspace_id
+        )
+
+        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
+        wm = context.window_manager
+        
+        # Account selection
+        row = layout.row()
+        if wm.selected_account_id != "NO_ACCOUNTS":
+            row.prop(self, "accounts", text="")
+        add_account_button_text = "Sign In" if wm.selected_account_id == "NO_ACCOUNTS" else ""
+        add_account_button_icon = 'WORLD' if wm.selected_account_id == "NO_ACCOUNTS" else 'ADD'
+        row.operator("speckle.add_account", icon=add_account_button_icon, text=add_account_button_text)
+        
+        # Workspace selection
+        row = layout.row()
+        if wm.selected_workspace_id != "NO_WORKSPACES":
+            row.prop(self, "workspaces", text="")
+
+        # Search field
+        row = layout.row(align=True)
+        row.prop(self, "search_query", icon="VIEWZOOM", text="")
+        row.operator("speckle.add_project_by_url", icon='LINKED', text="")
+
+        layout.template_list(
+            "SPECKLE_UL_projects_list",
+            "",
+            context.window_manager,
+            "speckle_projects",
+            self,
+            "project_index",
+        )
+        layout.separator()
+
+
+
+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)
+
+
+def unregister() -> None:
+
+    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,117 @@
+import bpy
+from typing import List
+from bpy.types import Operator, Context, Object
+from bpy.props import EnumProperty, StringProperty
+
+
+class SPECKLE_OT_selection_filter_dialog(Operator):
+    """
+    operator for handling object selection and filtering
+    """
+
+    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
+
+        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:
+        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}")
+
+        layout.prop(self, "selection_type")
+        layout.separator()
+
+        selected_objects: List[Object] = context.selected_objects
+        total_selected: int = len(selected_objects)
+
+        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")
+
+        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()
+
+    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,153 @@
+import bpy
+from bpy.types import UILayout, Context, PropertyGroup, Event
+from ..utils.version_manager import get_versions_for_model, get_latest_version
+
+
+class speckle_version(bpy.types.PropertyGroup):
+    """
+    PropertyGroup for storing version information
+    """
+
+    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
+    """
+
+    # 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:
+        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)
+
+        elif self.layout_type == "GRID":
+            layout.alignment = "CENTER"
+            layout.label(text=item.id)
+
+
+class SPECKLE_OT_version_selection_dialog(bpy.types.Operator):
+    bl_idname = "speckle.version_selection_dialog"
+    bl_label = "Select Version"
+
+    search_query: bpy.props.StringProperty(  # type: ignore
+        name="Search", description="Search a project", 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
+        wm.speckle_versions.clear()
+
+        search = self.search_query if self.search_query.strip() else None
+        versions = get_versions_for_model(
+            account_id=wm.selected_account_id,
+            project_id=wm.selected_project_id,
+            model_id=wm.selected_model_id,
+            search=search,
+        )
+
+        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
+
+        version_id_to_store = ""
+
+        if self.load_option == "LATEST":
+            latest_version = get_latest_version(
+                account_id=wm.selected_account_id,
+                project_id=wm.selected_project_id,
+                model_id=wm.selected_model_id,
+            )
+            if latest_version:
+                version_id_to_store = latest_version[0]
+            else:
+                print(
+                    f"Could not fetch latest version for model {wm.selected_model_id}"
+                )
+                return {"CANCELLED"}
+
+        elif self.load_option == "SPECIFIC":
+            if 0 <= self.version_index < len(wm.speckle_versions):
+                selected_version = wm.speckle_versions[self.version_index]
+                version_id_to_store = selected_version.id
+            else:
+                print(f"Invalid version index {self.version_index}")
+                return {"CANCELLED"}
+
+        wm.selected_version_id = version_id_to_store
+        wm.selected_version_load_option = self.load_option
+
+        print(f"Selected version: {version_id_to_store} (Option: {self.load_option})")
+
+        context.area.tag_redraw()
+
+        return {"FINISHED"}
+
+    def invoke(self, context: Context, event: Event) -> set[str]:
+        self.update_versions_list(context)
+
+        return context.window_manager.invoke_props_dialog(self)
+
+    def draw(self, context: Context) -> None:
+        layout: UILayout = self.layout
+        wm = context.window_manager
+        layout.label(text=f"Project: {wm.selected_project_name}")
+        layout.label(text=f"Model: {wm.selected_model_name}")
+
+        layout.prop(self, "load_option", expand=True)
+
+        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()

bpy_speckle/connector/utils/account_manager.py

@@ -0,0 +1,125 @@
+import bpy
+from specklepy.api.credentials import get_local_accounts
+from typing import List, Tuple, Optional
+from specklepy.core.api.credentials import Account
+from specklepy.api.client import SpeckleClient
+from .misc import strip_non_ascii
+
+
+class speckle_account(bpy.types.PropertyGroup):
+    id: bpy.props.StringProperty()  # type: ignore
+    user_name: bpy.props.StringProperty()  # type: ignore
+    server_url: bpy.props.StringProperty()  # type: ignore
+    user_email: bpy.props.StringProperty()  # type: ignore
+
+
+class speckle_workspace(bpy.types.PropertyGroup):
+    """
+    PropertyGroup for storing workspace information
+    """
+
+    id: bpy.props.StringProperty(name="ID")  # type: ignore
+    name: bpy.props.StringProperty()  # type: ignore
+
+
+def get_account_enum_items() -> List[Tuple[str, str, str, str]]:
+    accounts: List[Account] = get_local_accounts()
+    if not accounts:
+        print("No accounts found!")
+        return [("NO_ACCOUNTS", "No accounts found!", "", "")]
+    print("Accounts added")
+    speckle_accounts = []
+    for acc in accounts:
+        speckle_accounts.append(
+            (
+                acc.id,
+                strip_non_ascii(acc.userInfo.name),
+                acc.serverInfo.url,
+                acc.userInfo.email,
+            )
+        )
+    return speckle_accounts
+
+
+def get_workspaces(account_id: str) -> List[Tuple[str, str]]:
+    """
+    retrieves the workspaces for a given account ID
+    """
+    account = next((acc for acc in get_local_accounts() if acc.id == account_id), None)
+    client = SpeckleClient(host=account.serverInfo.url)
+    client.authenticate_with_account(account)
+    workspaces_enabled = client.server.get().workspaces.workspaces_enabled
+
+    if workspaces_enabled:
+        workspaces = client.active_user.get_workspaces().items
+        workspace_list = [
+            (ws.id, strip_non_ascii(ws.name))
+            for ws in workspaces
+            if ws.creation_state == None or ws.creation_state.completed
+        ]
+        personal_projects_text = "Personal Projects (Legacy)"
+    else:
+        workspace_list = []
+        personal_projects_text = "Personal Projects"
+    # Append Personal Projects do workspace dropdown
+    if client.active_user.can_create_personal_projects().authorized:
+        workspace_list.append(("personal", personal_projects_text))
+
+    print("Workspaces added")
+    return (
+        reorder_tuple(workspace_list, get_default_workspace_id(account_id))
+        if workspaces_enabled
+        else workspace_list
+    )
+
+
+def get_default_account_id() -> Optional[str]:
+    """
+    retrieves the ID of the default Speckle account
+    """
+    return next(
+        (acc.id for acc in get_local_accounts() if acc.isDefault), "NO_ACCOUNTS"
+    )
+
+
+def get_server_url_by_account_id(account_id: str) -> Optional[str]:
+    """
+    retrieves the server URL for a given account ID
+    """
+    accounts: List[Account] = get_local_accounts()
+    for acc in accounts:
+        if acc.id == account_id:
+            return acc.serverInfo.url
+    return None
+
+
+def get_default_workspace_id(account_id: str) -> Optional[str]:
+    """
+    retrieves the ID of the default workspace for a given account ID
+    """
+    account = next((acc for acc in get_local_accounts() if acc.id == account_id), None)
+    client = SpeckleClient(host=account.serverInfo.url)
+    client.authenticate_with_account(account)
+    return (
+        client.active_user.get_active_workspace().id
+        if client.active_user.get_active_workspace()
+        else "personal"
+    )
+
+
+def get_account_from_id(account_id: str) -> Optional[Account]:
+    return next((acc for acc in get_local_accounts() if acc.id == account_id), None)
+
+
+def reorder_tuple(tuple_list, target_id):
+    for i, (id, value) in enumerate(tuple_list):
+        if id == target_id:
+            # Remove the tuple from its current position
+            target_tuple = tuple_list.pop(i)
+            # Insert it at the beginning of the list
+            tuple_list.insert(0, target_tuple)
+            return tuple_list
+
+    # If the target_id wasn't found
+    print(f"Tuple with ID {target_id} not found in the list")
+    return tuple_list

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,51 @@
+from datetime import datetime, timezone
+import re
+
+def format_relative_time(timestamp) -> str:
+    """
+    convert UTC timestamp to local timezone and return relative time string
+    """
+    if not timestamp:
+        return "Unknown"
+
+    # convert to local timezone
+    try:
+        try:
+            dt = datetime.fromisoformat(str(timestamp).replace("Z", "+00:00"))
+        except ValueError:
+            try:
+                ts = float(timestamp)
+                dt = datetime.fromtimestamp(ts / 1000, tz=timezone.utc)
+            except (ValueError, TypeError):
+                return "Invalid timestamp"
+
+        local_dt = dt.astimezone()
+
+        # calculate relative time
+        now = datetime.now(timezone.utc).astimezone()
+        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
+    """
+    split_role = role.split(":")
+    return f"{split_role[1]}"
+
+def strip_non_ascii(text):
+    # Keep English letters, digits, spaces and basic punctuation
+    return re.sub(r'[^a-zA-Z0-9\s.,!?]', '', text)

bpy_speckle/connector/utils/model_manager.py

@@ -0,0 +1,52 @@
+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, strip_non_ascii
+
+
+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
+    """
+    try:
+        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 []
+
+        client = SpeckleClient(host=account.serverInfo.url)
+        client.authenticate_with_account(account)
+
+        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
+
+        models: List[Model] = client.model.get_models(
+            project_id=project_id, models_limit=10, models_filter=filter
+        ).items
+
+        return [
+            (strip_non_ascii(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,48 @@
+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, strip_non_ascii
+
+def get_projects_for_account(
+    account_id: str, workspace_id: str = None, search: Optional[str] = None
+) -> List[Tuple[str, str, str, str]]:
+    """
+    fetches projects for a given account from the Speckle server
+    """
+    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 []
+
+        client = SpeckleClient(host=account.serverInfo.url)
+        client.authenticate_with_account(account)
+
+        personal_only = workspace_id == "personal"
+        workspace_id = None if personal_only else workspace_id
+        filter = UserProjectsFilter(search=search, workspaceId=workspace_id, personalOnly=personal_only)
+
+        projects = client.active_user.get_projects(limit=10, filter=filter).items
+
+        return [
+            (
+                strip_non_ascii(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,100 @@
+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, strip_non_ascii
+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
+    """
+    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
+        )
+
+        return [
+            (
+                version.id,
+                version.message if version.message is not None else "No message",
+                format_relative_time(version.created_at),
+            )
+            for version in versions
+            if version.referenced_object is not None
+        ]
+
+    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 if latest.message is not None else "No message",
+            format_relative_time(latest.created_at),
+        )
+
+    except Exception as e:
+        print(f"Error fetching latest version: {str(e)}")
+        return ("", "", "")

bpy_speckle/convert/__init__.py

@@ -1,313 +0,0 @@
-import bpy, idprop
-from mathutils import Matrix
-
-from .from_speckle import *
-from .to_speckle import *
-from .util import *
-from bpy_speckle.functions import _report, get_scale_length
-
-from specklepy.objects.geometry import *
-from specklepy.objects.other import RenderMaterial
-
-
-FROM_SPECKLE_SCHEMAS = {
-    Mesh: import_mesh,
-    Brep: import_brep,
-    Curve: import_curve,
-    Line: import_curve,
-    Polyline: import_curve,
-    Polycurve: import_curve,
-    Arc: import_curve,
-}
-
-
-TO_SPECKLE = {
-    "MESH": export_mesh,
-    "CURVE": export_curve,
-    "EMPTY": export_empty,
-}
-
-
-def set_transform(speckle_object, blender_object):
-    transform = None
-    if hasattr(speckle_object, "transform"):
-        transform = speckle_object.transform
-    elif (
-        hasattr(speckle_object, "properties") and speckle_object.properties is not None
-    ):
-        transform = speckle_object.properties.get("transform", None)
-
-    if transform and len(transform) == 16:
-        mat = Matrix(
-            [transform[0:4], transform[4:8], transform[8:12], transform[12:16]]
-        )
-        blender_object.matrix_world = mat
-
-
-def add_blender_material(smesh, blender_object) -> None:
-    """Add material to a blender object if the corresponding speckle object has a render material"""
-    if blender_object.data is None:
-        return
-
-    if not hasattr(smesh, "renderMaterial") and not hasattr(smesh, "@renderMaterial"):
-        return
-
-    speckle_mat = getattr(smesh, "renderMaterial", None) or smesh["@renderMaterial"]
-    mat_name = getattr(speckle_mat, "name", None) or speckle_mat.__dict__.get("@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 not blender_mat:
-        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)
-        inputs["Emission"].default_value = to_rgba(speckle_mat.emissive)
-        inputs["Roughness"].default_value = speckle_mat.roughness
-        inputs["Metallic"].default_value = speckle_mat.metalness
-        inputs["Alpha"].default_value = speckle_mat.opacity
-
-    if speckle_mat.opacity < 1:
-        blender_mat.blend_method = "BLEND"
-
-    blender_object.data.materials.append(blender_mat)
-
-
-def material_to_speckle(blender_object) -> RenderMaterial:
-    """Create and return a render material from a blender object"""
-    if not getattr(blender_object.data, "materials", None):
-        return
-
-    blender_mat = blender_object.data.materials[0]
-    speckle_mat = RenderMaterial()
-    speckle_mat.name = blender_mat.name
-
-    if blender_mat.use_nodes is True:
-        inputs = blender_mat.node_tree.nodes["Principled BSDF"].inputs
-        speckle_mat.diffuse = to_argb_int(inputs["Base Color"].default_value)
-        speckle_mat.emissive = to_argb_int(inputs["Emission"].default_value)
-        speckle_mat.roughness = inputs["Roughness"].default_value
-        speckle_mat.metalness = inputs["Metallic"].default_value
-        speckle_mat.opacity = inputs["Alpha"].default_value
-
-    else:
-        speckle_mat.diffuse = to_argb_int(blender_mat.diffuse_color)
-        speckle_mat.metalness = blender_mat.metallic
-        speckle_mat.roughness = blender_mat.roughness
-
-    return speckle_mat
-
-
-def try_add_property(speckle_object, blender_object, prop, prop_name):
-    if prop in speckle_object.keys() and speckle_object[prop] is not None:
-        blender_object[prop_name] = speckle_object[prop]
-
-
-# def add_dictionary(prop, blender_object, superkey=None):
-#     for key in prop.keys():
-#         key_name = "{}.{}".format(superkey, key) if superkey else "{}".format(key)
-#         if isinstance(prop[key], dict):
-#             subtype = prop[key].get("type", None)
-#             if subtype and subtype in FROM_SPECKLE.keys():
-#                 continue
-#             else:
-#                 add_dictionary(prop[key], blender_object, key_name)
-#         elif hasattr(prop[key], "type"):
-#             subtype = prop[key].type
-#             if subtype and subtype in FROM_SPECKLE.keys():
-#                 continue
-#         else:
-#             try:
-#                 blender_object[key_name] = prop[key]
-#             except KeyError:
-#                 pass
-
-
-def add_custom_properties(speckle_object, blender_object):
-
-    if blender_object is None:
-        return
-
-    blender_object["_speckle_type"] = type(speckle_object).__name__
-    # blender_object['_speckle_name'] = "SpeckleObject"
-
-    ignore = ["_chunkable", "_units", "units"]
-
-    if hasattr(speckle_object, "applicationId"):
-        blender_object["applicationId"] = speckle_object.applicationId
-
-    for key in speckle_object.get_dynamic_member_names():
-        if key in ignore:
-            continue
-        if isinstance(speckle_object[key], (int, str, float, dict)):
-            blender_object[key] = speckle_object[key]
-
-
-def dict_to_speckle_object(data):
-    if "type" in data.keys() and data["type"] in SCHEMAS.keys():
-        obj = SCHEMAS[data["type"]].parse_obj(data)
-        for key in obj.properties.keys():
-            if isinstance(obj.properties[key], dict):
-                obj.properties[key] = dict_to_speckle_object(obj.properties[key])
-            elif isinstance(obj.properties[key], list):
-                for i in range(len(obj.properties[key])):
-                    if isinstance(obj.properties[key][i], dict):
-                        obj.properties[key][i] = dict_to_speckle_object(
-                            obj.properties[key][i]
-                        )
-        return obj
-    else:
-        for key in data.keys():
-            if isinstance(data[key], dict):
-                data[key] = dict_to_speckle_object(data[key])
-            elif isinstance(data[key], list):
-                for i in range(len(data[key])):
-                    if isinstance(data[key][i], dict):
-                        data[key][i] = dict_to_speckle_object(data[key][i])
-        return data
-
-
-def from_speckle_object(speckle_object, scale, name=None):
-    speckle_name = (
-        name
-        or getattr(speckle_object, "name", None)
-        or speckle_object.speckle_type + f" -- {speckle_object.id}"
-    )
-
-    units = getattr(speckle_object, "units", None)
-    if units:
-        scale = get_scale_length(units) / bpy.context.scene.unit_settings.scale_length
-
-    # try native conversion
-    if type(speckle_object) in FROM_SPECKLE_SCHEMAS.keys():
-        print("Got object type: {}".format(type(speckle_object)))
-
-        try:
-            obdata = FROM_SPECKLE_SCHEMAS[type(speckle_object)](
-                speckle_object, scale, speckle_name
-            )
-        except Exception as e:  # conversion error
-            _report(f"Error converting {speckle_object} \n{e}")
-            return None
-
-        if speckle_name in bpy.data.objects.keys():
-            blender_object = bpy.data.objects[speckle_name]
-            blender_object.data = obdata
-            blender_object.matrix_world = Matrix()
-            if hasattr(obdata, "materials"):
-                blender_object.data.materials.clear()
-        else:
-            blender_object = bpy.data.objects.new(speckle_name, obdata)
-
-        blender_object.speckle.object_id = str(speckle_object.id)
-        blender_object.speckle.enabled = True
-
-        add_custom_properties(speckle_object, blender_object)
-        add_blender_material(speckle_object, blender_object)
-        # TODO: chat with tom re transforms
-        # set_transform(speckle_object, blender_object)
-
-        return blender_object
-
-    # try display mesh
-    mesh = getattr(
-        speckle_object, "displayMesh", getattr(speckle_object, "displayValue", None)
-    )
-    if mesh:
-        return from_speckle_object(mesh, scale, speckle_name)
-
-    # return none if fail
-    _report("Invalid input: {}".format(speckle_object))
-    return None
-
-
-def get_speckle_subobjects(attr, scale, name):
-
-    subobjects = []
-    for key in attr.keys():
-        if isinstance(attr[key], dict):
-            subtype = attr[key].get("type", None)
-            if subtype:
-                name = "{}.{}".format(name, key)
-                # print("{} :: {}".format(name, subtype))
-                subobject = from_speckle_object(attr[key], scale, name)
-                add_custom_properties(attr[key], subobject)
-
-                subobjects.append(subobject)
-                props = attr[key].get("properties", None)
-                if props:
-                    subobjects.extend(get_speckle_subobjects(props, scale, name))
-        elif hasattr(attr[key], "type"):
-            subtype = attr[key].type
-            if subtype:
-                name = "{}.{}".format(name, key)
-                # print("{} :: {}".format(name, subtype))
-                subobject = from_speckle_object(attr[key], scale, name)
-                add_custom_properties(attr[key], subobject)
-
-                subobjects.append(subobject)
-                props = attr[key].get("properties", None)
-                if props:
-                    subobjects.extend(get_speckle_subobjects(props, scale, name))
-    return subobjects
-
-
-ignored_keys = [
-    "speckle",
-    "_speckle_type",
-    "_speckle_name",
-    "_speckle_transform",
-    "_RNA_UI",
-    "transform",
-    "_units",
-    "_chunkable",
-]
-
-
-def get_blender_custom_properties(obj, max_depth=1000):
-    global ignored_keys
-
-    if max_depth < 0:
-        return obj
-
-    if hasattr(obj, "keys"):
-        return {
-            key: get_blender_custom_properties(obj[key], max_depth - 1)
-            for key in obj.keys()
-            if key not in ignored_keys and not key.startswith("_")
-        }
-
-    elif isinstance(obj, (list, tuple, idprop.types.IDPropertyArray)):
-        return [get_blender_custom_properties(o, max_depth - 1) for o in obj]
-    else:
-        return obj
-
-
-def to_speckle_object(blender_object, scale, desgraph=None):
-    blender_type = blender_object.type
-    speckle_objects = []
-    speckle_material = material_to_speckle(blender_object)
-
-    if blender_type in TO_SPECKLE.keys():
-        if desgraph:
-            blender_object = blender_object.evaluated_get(desgraph)
-        converted = TO_SPECKLE[blender_type](blender_object, blender_object.data, scale)
-        if isinstance(converted, list):
-            speckle_objects.extend([c for c in converted if c != None])
-
-    for so in speckle_objects:
-        so.properties = get_blender_custom_properties(blender_object)
-        so.applicationId = so.properties.pop("applicationId", None)
-
-        if speckle_material:
-            so["renderMaterial"] = speckle_material
-
-        # Set object transform
-        so.properties["transform"] = [y for x in blender_object.matrix_world for y in x]
-
-    # _report(speckle_objects)
-    return speckle_objects

bpy_speckle/convert/from_speckle/__init__.py

@@ -1,3 +0,0 @@
-from .mesh import import_mesh
-from .curve import import_curve
-from .brep import import_brep

bpy_speckle/convert/from_speckle/brep.py

@@ -1,24 +0,0 @@
-import bpy
-from .mesh import to_bmesh
-from bpy_speckle.util import find_key_case_insensitive
-
-
-def import_brep(speckle_brep, scale, name=None):
-    if not name:
-        name = speckle_brep.geometryHash or speckle_brep.id
-
-    display = getattr(
-        speckle_brep, "displayMesh", getattr(speckle_brep, "displayValue", None)
-    )
-    if display:
-        if name in bpy.data.meshes.keys():
-            mesh = bpy.data.meshes[name]
-        else:
-            mesh = bpy.data.meshes.new(name=name)
-
-        to_bmesh(display, mesh, name, scale)
-        # add_custom_properties(speckle_brep[dvKey], mesh)
-    else:
-        mesh = None
-
-    return mesh

bpy_speckle/convert/from_speckle/curve.py

@@ -1,237 +0,0 @@
-import bpy, math
-from bpy_speckle.util import find_key_case_insensitive
-import mathutils
-from specklepy.objects.geometry import *
-
-CONVERT = {}
-
-
-def import_line(scurve, bcurve, scale):
-    line = bcurve.splines.new("POLY")
-    line.points.add(1)
-
-    line.points[0].co = (
-        float(scurve.start.x) * scale,
-        float(scurve.start.y) * scale,
-        float(scurve.start.z) * scale,
-        1,
-    )
-
-    if scurve.end:
-
-        line.points[1].co = (
-            float(scurve.end.x) * scale,
-            float(scurve.end.y) * scale,
-            float(scurve.end.z) * scale,
-            1,
-        )
-
-        return line
-
-
-CONVERT[Line] = import_line
-
-
-def import_polyline(scurve, bcurve, scale):
-
-    # value = find_key_case_insensitive(scurve, "value")
-    value = scurve.value
-
-    if value:
-        N = int(len(value) / 3)
-
-        polyline = bcurve.splines.new("POLY")
-
-        if hasattr(scurve, "closed"):
-            polyline.use_cyclic_u = scurve.closed
-
-        # if "closed" in scurve.keys():
-        #    polyline.use_cyclic_u = scurve["closed"]
-
-        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
-
-
-CONVERT[Polyline] = import_polyline
-
-
-def import_nurbs_curve(scurve, bcurve, scale):
-
-    # points = find_key_case_insensitive(scurve, "points")
-    points = scurve.points
-
-    if points:
-        N = int(len(points) / 3)
-
-        nurbs = bcurve.splines.new("NURBS")
-
-        if hasattr(scurve, "closed"):
-            nurbs.use_cyclic_u = scurve.closed != 0
-
-        nurbs.points.add(N - 1)
-        for i in range(N):
-            nurbs.points[i].co = (
-                float(points[i * 3]) * scale,
-                float(points[i * 3 + 1]) * scale,
-                float(points[i * 3 + 2]) * scale,
-                1,
-            )
-
-        if len(scurve.weights) == len(nurbs.points):
-            for i, w in enumerate(scurve.weights):
-                nurbs.points[i].weight = w
-
-        # TODO: anaylize curve knots to decide if use_endpoint_u or use_bezier_u should be enabled
-        # nurbs.use_endpoint_u = True
-        nurbs.order_u = scurve.degree + 1
-
-        return nurbs
-
-
-CONVERT[Curve] = import_nurbs_curve
-
-
-def import_arc(rcurve, bcurve, scale):
-    """
-    Convert Arc object
-    TODO: improve Blender representation of arc
-    """
-    plane = rcurve.plane
-    if not plane:
-        return
-
-    origin = plane.origin
-    normal = mathutils.Vector([plane.normal.x, plane.normal.y, plane.normal.z])
-
-    xaxis = plane.xdir
-    yaxis = plane.ydir
-
-    radius = rcurve.radius * scale
-    startAngle = rcurve.startAngle
-    endAngle = rcurve.endAngle
-
-    startQuat = mathutils.Quaternion(normal, startAngle)
-    endQuat = mathutils.Quaternion(normal, endAngle)
-
-    """
-    Get start and end vectors, centre point, angles, etc.
-    """
-
-    r1 = mathutils.Vector([plane.xdir.x, plane.xdir.y, plane.xdir.z])
-    r1.rotate(startQuat)
-
-    r2 = mathutils.Vector([plane.xdir.x, plane.xdir.y, plane.xdir.z])
-    r2.rotate(endQuat)
-
-    c = mathutils.Vector([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 = mathutils.Quaternion(normal, step)
-    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
-
-
-CONVERT[Arc] = import_arc
-
-
-def import_null(speckle_object, bcurve, scale):
-    """
-    Handle unsupported types
-    """
-    print("Failed to convert type", speckle_object["type"])
-    return None
-
-
-def import_polycurve(scurve, bcurve, scale):
-    """
-    Convert Polycurve object
-    """
-    segments = scurve.segments
-
-    curves = []
-
-    for seg in segments:
-        speckle_type = type(seg)
-
-        if speckle_type in CONVERT.keys():
-            # segcurve = SCHEMAS[speckle_type].parse_obj(seg)
-            curves.append(CONVERT[speckle_type](seg, bcurve, scale))
-        else:
-            print("Unsupported curve type: {}".format(speckle_type))
-
-    return curves
-
-
-CONVERT[Polycurve] = import_polycurve
-
-
-def import_curve(speckle_curve, scale, name=None):
-    """
-    Convert Curve object
-    """
-    if not name:
-        name = speckle_curve.geometryHash or speckle_curve.id or "SpeckleCurve"
-
-    if name in bpy.data.curves.keys():
-        curve_data = bpy.data.curves[name]
-    else:
-        curve_data = bpy.data.curves.new(name, type="CURVE")
-
-    curve_data.dimensions = "3D"
-    curve_data.resolution_u = 12
-
-    if type(speckle_curve) not in CONVERT.keys():
-        print("Unsupported curve type: {}".format(speckle_curve.type))
-        return None
-
-    CONVERT[type(speckle_curve)](speckle_curve, curve_data, scale)
-
-    return curve_data

bpy_speckle/convert/from_speckle/mesh.py

@@ -1,145 +0,0 @@
-import bpy, bmesh, struct
-import base64
-from bpy_speckle.functions import _report
-
-
-def add_vertices(smesh, bmesh, scale=1.0):
-    sverts = smesh.vertices
-
-    if sverts and len(sverts) > 0:
-        for i in range(0, len(sverts), 3):
-            bmesh.verts.new(
-                (
-                    float(sverts[i]) * scale,
-                    float(sverts[i + 1]) * scale,
-                    float(sverts[i + 2]) * scale,
-                )
-            )
-
-    bmesh.verts.ensure_lookup_table()
-
-
-def add_faces(smesh, bmesh, smooth=False):
-    sfaces = smesh.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 = bmesh.faces.new([bmesh.verts[int(x)] for x in sfaces[i : i + n]])
-                f.smooth = smooth
-            except Exception as e:
-                _report(f"Failed to create face for mesh {smesh.id} \n{e}")
-            i += n
-
-        bmesh.faces.ensure_lookup_table()
-        bmesh.verts.index_update()
-
-
-def add_colors(smesh, bmesh):
-
-    scolors = smesh.colors
-
-    if scolors:
-        colors = []
-        if len(scolors) > 0:
-
-            for i in range(len(scolors)):
-                col = int(scolors[i])
-                (a, r, g, b) = [
-                    int(x) for x in struct.unpack("!BBBB", struct.pack("!i", col))
-                ]
-                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(bmesh.verts):
-            color_layer = bmesh.loops.layers.color.new("Col")
-
-            for face in bmesh.faces:
-                for loop in face.loops:
-                    loop[color_layer] = colors[loop.vert.index]
-
-
-def add_uv_coords(smesh, bmesh):
-    if not hasattr(smesh, "properties"):
-        return
-
-    sprops = smesh.properties
-    if sprops:
-        texKey = ""
-        if "texture_coordinates" in sprops.keys():
-            texKey = "texture_coordinates"
-        elif "TextureCoordinates" in sprops.keys():
-            texKey = "TextureCoordinates"
-
-        if texKey != "":
-
-            try:
-                decoded = base64.b64decode(sprops[texKey]).decode("utf-8")
-                s_uvs = decoded.split()
-                uv = []
-
-                if int(len(s_uvs) / 2) == len(bmesh.verts):
-                    for i in range(0, len(s_uvs), 2):
-                        uv.append((float(s_uvs[i]), float(s_uvs[i + 1])))
-                else:
-                    print(len(s_uvs) * 2)
-                    print(len(bmesh.verts))
-                    print("Failed to match UV coordinates to vert data.")
-
-                # Make UVs
-                uv_layer = bmesh.loops.layers.uv.verify()
-
-                for f in bmesh.faces:
-                    for l in f.loops:
-                        luv = l[uv_layer]
-                        luv.uv = uv[l.vert.index]
-            except:
-                print("Failed to decode texture coordinates.")
-                raise
-
-            del smesh.properties[texKey]
-
-
-def to_bmesh(speckle_mesh, blender_mesh, name="SpeckleMesh", scale=1.0):
-    bm = bmesh.new()
-
-    add_vertices(speckle_mesh, bm, scale)
-    add_faces(speckle_mesh, bm)
-    add_colors(speckle_mesh, bm)
-    add_uv_coords(speckle_mesh, bm)
-
-    bmesh.ops.recalc_face_normals(bm, faces=bm.faces)
-    bm.to_mesh(blender_mesh)
-    bm.free()
-
-    return blender_mesh
-
-
-def import_mesh(speckle_mesh, scale=1.0, name=None):
-    """
-    Convert Mesh object
-    """
-    if not name:
-        name = speckle_mesh.geometryHash or speckle_mesh.id
-
-    if name in bpy.data.meshes.keys():
-        mesh = bpy.data.meshes[name]
-    else:
-        mesh = bpy.data.meshes.new(name=name)
-
-    to_bmesh(speckle_mesh, mesh, name, scale)
-
-    return mesh

bpy_speckle/convert/from_speckle/plane.py

@@ -1,6 +0,0 @@
-import bpy, bmesh, struct
-import base64
-
-
-def import_plane(speckle_plane, scale=1.0, name=None):
-    return None

bpy_speckle/convert/to_speckle/__init__.py

@@ -1,3 +0,0 @@
-from .mesh import export_mesh
-from .curve import export_curve, export_ngons_as_polylines
-from .empty import export_empty

bpy_speckle/convert/to_speckle/curve.py

@@ -1,224 +0,0 @@
-import bpy, bmesh, struct
-from specklepy.objects.geometry import Curve, Interval, Box, Polyline
-from bpy_speckle.convert.to_speckle.mesh import export_mesh
-
-UNITS = "m"
-
-
-def bezier_to_speckle(matrix, spline, scale, name=None):
-    degree = 3
-    closed = spline.use_cyclic_u
-
-    points = []
-    for i, bp in enumerate(spline.bezier_points):
-        if i > 0:
-            points.append(tuple(matrix @ bp.handle_left * scale))
-        points.append(tuple(matrix @ bp.co * scale))
-        if i < len(spline.bezier_points) - 1:
-            points.append(tuple(matrix @ bp.handle_right * scale))
-
-    if closed:
-        points.append(tuple(matrix @ spline.bezier_points[-1].handle_right * scale))
-        points.append(tuple(matrix @ spline.bezier_points[0].handle_left * scale))
-        points.append(tuple(matrix @ spline.bezier_points[0].co * scale))
-
-    num_points = len(points)
-
-    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=spline.use_cyclic_u,
-        points=list(sum(points, ())),  # magic (flatten list of tuples)
-        weights=[1] * num_points,
-        knots=knots,
-        rational=False,
-        area=0,
-        volume=0,
-        length=length,
-        domain=domain,
-        units=UNITS,
-        bbox=Box(area=0.0, volume=0.0),
-    )
-
-
-def nurbs_to_speckle(matrix, spline, scale, name=None):
-    knots = makeknots(spline)
-    # print("knots: {}".format(knots))
-    points = [tuple(matrix @ pt.co.xyz * scale) for pt in spline.points]
-    degree = spline.order_u - 1
-
-    length = spline.calc_length()
-    domain = Interval(start=0, end=length, totalChildrenCount=0)
-
-    return Curve(
-        name=name,
-        degree=degree,
-        closed=spline.use_cyclic_u,
-        periodic=spline.use_cyclic_u,
-        points=list(sum(points, ())),  # magic (flatten list of tuples)
-        weights=[pt.weight for pt in spline.points],
-        knots=knots,
-        rational=False,
-        area=0,
-        volume=0,
-        length=length,
-        domain=domain,
-        units=UNITS,
-        bbox=Box(area=0.0, volume=0.0),
-    )
-
-
-def poly_to_speckle(matrix, spline, scale, name=None):
-    points = [tuple(matrix @ pt.co.xyz * scale) for pt in spline.points]
-
-    length = spline.calc_length()
-    domain = Interval(start=0, end=length, totalChildrenCount=0)
-    return Polyline(
-        name=name,
-        closed=spline.use_cyclic_u,
-        value=list(sum(points, ())),  # magic (flatten list of tuples)
-        length=length,
-        domain=domain,
-        bbox=Box(area=0.0, volume=0.0),
-        area=0,
-        units=UNITS,
-    )
-
-
-def export_curve(blender_object, data, scale=1.0):
-    UNITS = "m" if bpy.context.scene.unit_settings.system == "METRIC" else "ft"
-
-    if blender_object.type != "CURVE":
-        return None
-
-    blender_object = blender_object.evaluated_get(bpy.context.view_layer.depsgraph)
-
-    mat = blender_object.matrix_world
-
-    curves = []
-
-    if data.bevel_mode == "OBJECT" and data.bevel_object != None:
-        mesh = export_mesh(blender_object, blender_object.to_mesh(), scale)
-        curves.extend(mesh)
-
-    for spline in data.splines:
-        if spline.type == "BEZIER":
-            curves.append(bezier_to_speckle(mat, spline, scale, blender_object.name))
-
-        elif spline.type == "NURBS":
-            curves.append(nurbs_to_speckle(mat, spline, scale, blender_object.name))
-
-        elif spline.type == "POLY":
-            curves.append(poly_to_speckle(mat, spline, scale, blender_object.name))
-
-    return curves
-
-
-def export_ngons_as_polylines(blender_object, data, scale=1.0):
-    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 * scale)
-
-        domain = Interval(start=0, end=1)
-        poly = Polyline(
-            name="{}_{}".format(blender_object.name, i),
-            closed=True,
-            value=value,  # magic (flatten list of tuples)
-            length=0,
-            domain=domain,
-            bbox=Box(area=0.0, volume=0.0),
-            area=0,
-            units=UNITS,
-        )
-
-        polylines.append(poly)
-
-    return polylines
-
-
-"""
-Python implementation of Blender's NURBS curve generation
-from: https://blender.stackexchange.com/a/34276
-"""
-
-
-def macro_knotsu(nu):
-    return nu.order_u + nu.point_count_u + (nu.order_u - 1 if nu.use_cyclic_u else 0)
-
-
-def macro_segmentsu(nu):
-    return nu.point_count_u if nu.use_cyclic_u else nu.point_count_u - 1
-
-
-def makeknots(nu):
-    knots = [0.0] * (4 + macro_knotsu(nu))
-    flag = nu.use_endpoint_u + (nu.use_bezier_u << 1)
-    if nu.use_cyclic_u:
-        calcknots(knots, nu.point_count_u, nu.order_u, 0)
-        makecyclicknots(knots, nu.point_count_u, nu.order_u)
-    else:
-        calcknots(knots, nu.point_count_u, nu.order_u, flag)
-    return knots
-
-
-def calcknots(knots, pnts, order, flag):
-    pnts_order = pnts + order
-    if flag == 1:
-        k = 0.0
-        for a in range(1, pnts_order + 1):
-            knots[a - 1] = k
-            if a >= order and a <= pnts:
-                k += 1.0
-    elif flag == 2:
-        if order == 4:
-            k = 0.34
-            for a in range(pnts_order):
-                knots[a] = math.floor(k)
-                k += 1.0 / 3.0
-        elif order == 3:
-            k = 0.6
-            for a in range(pnts_order):
-                if a >= order and a <= pnts:
-                    k += 0.5
-                    knots[a] = math.floor(k)
-    else:
-        for a in range(pnts_order):
-            knots[a] = a
-
-
-def makecyclicknots(knots, pnts, order):
-    order2 = order - 1
-
-    if order > 2:
-        b = pnts + order2
-        for a in range(1, order2):
-            if knots[b] != knots[b - a]:
-                break
-
-            if a == order2:
-                knots[pnts + order - 2] += 1.0
-
-    b = order
-    c = pnts + order + order2
-    for a in range(pnts + order2, c):
-        knots[a] = knots[a - 1] + (knots[b] - knots[b - 1])
-        b -= 1

bpy_speckle/convert/to_speckle/default.py

@@ -1,5 +0,0 @@
-import bpy, bmesh, struct
-
-
-def export_default(blender_object, scale=1.0):
-    return None

bpy_speckle/convert/to_speckle/empty.py

@@ -1,5 +0,0 @@
-import bpy, bmesh, struct
-
-
-def export_empty(blender_object, data, scale=1.0):
-    return None

bpy_speckle/convert/to_speckle/mesh.py

@@ -1,44 +0,0 @@
-import bpy, bmesh, struct
-
-import base64, hashlib
-from time import strftime, gmtime
-
-from specklepy.objects.geometry import Mesh, Interval, Box
-
-
-def export_mesh(blender_object, data, scale=1.0):
-    if data.loop_triangles is None or len(data.loop_triangles) < 1:
-        data.calc_loop_triangles()
-
-    mat = blender_object.matrix_world
-
-    verts = [tuple(mat @ x.co * scale) for x in data.vertices]
-
-    faces = [p.vertices for p in data.polygons]
-    unit_system = bpy.context.scene.unit_settings.system
-
-    sm = Mesh(
-        name=blender_object.name,
-        vertices=list(sum(verts, ())),
-        faces=[],
-        colors=[],
-        textureCoordinates=[],
-        units="m" if unit_system == "METRIC" else "ft",
-        bbox=Box(area=0.0, volume=0.0),
-    )
-
-    if data.uv_layers.active:
-        for vt in data.uv_layers.active.data:
-            sm.textureCoordinates.extend([vt.uv.x, vt.uv.y])
-
-    for f in faces:
-        n = len(f)
-        if n == 3:
-            sm.faces.append(0)
-        elif n == 4:
-            sm.faces.append(1)
-        else:
-            sm.faces.append(n)
-        sm.faces.extend(f)
-
-    return [sm]

bpy_speckle/convert/util.py

@@ -1,19 +0,0 @@
-from typing import Tuple
-
-
-def to_rgba(argb_int: int) -> Tuple[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(diffuse_colour) -> int:
-    """Converts an RGBA array to an ARGB integer"""
-    diffuse_colour = diffuse_colour[-1:] + diffuse_colour[0:3]
-    diffuse_colour = [int(val * 255) for val in diffuse_colour]
-
-    return int.from_bytes(diffuse_colour, byteorder="big", signed=True)

bpy_speckle/converter/__init__.py

@@ -0,0 +1,2 @@
+from ..converter.to_native import * #noqa: F403
+from ..converter.utils import *  # noqa: F403

bpy_speckle/converter/utils.py

@@ -0,0 +1,179 @@
+from typing import Tuple, List, Optional
+import bpy
+import mathutils
+from specklepy.objects import Base
+from specklepy.objects.graph_traversal.default_traversal import (
+    create_default_traversal_function,
+)
+
+
+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
+    """
+    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
+
+    for node in nodes:
+        nodes.remove(node)
+
+    bsdf = nodes.new(type="ShaderNodeBsdfPrincipled")
+    output = nodes.new(type="ShaderNodeOutputMaterial")
+
+    node_tree.links.new(bsdf.outputs["BSDF"], output.inputs["Surface"])
+
+    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
+
+
+def transform_matrix(transform: List[float]) -> mathutils.Matrix:
+    """
+    converts a speckle transform array to a 4x4 matrix (blender needs it)
+    """
+
+    if len(transform) != 16:
+        raise ValueError(f"Expected transform with 16 values, got {len(transform)}")
+
+    return mathutils.Matrix(
+        (
+            (transform[0], transform[4], transform[8], transform[12]),
+            (transform[1], transform[5], transform[9], transform[13]),
+            (transform[2], transform[6], transform[10], transform[14]),
+            (transform[3], transform[7], transform[11], transform[15]),
+        )
+    )
+
+
+def find_object_by_id(root_object: Base, target_id: str) -> Optional[Base]:
+    """
+    finds an object using traversal, checking both id and applicationId
+    """
+    if hasattr(root_object, "__closure") and root_object.__closure:
+        if target_id in root_object.__closure:
+            if hasattr(root_object, "elements"):
+                for element in root_object.elements:
+                    if hasattr(element, "id") and element.id == target_id:
+                        return element
+                    if (
+                        hasattr(element, "referencedId")
+                        and element.referencedId == target_id
+                    ):
+                        return find_object_by_id(root_object, element.referencedId)
+
+            if hasattr(root_object, "@elements"):
+                for element in root_object["@elements"]:
+                    if hasattr(element, "id") and element.id == target_id:
+                        return element
+                    if (
+                        hasattr(element, "referencedId")
+                        and element.referencedId == target_id
+                    ):
+                        return find_object_by_id(root_object, element.referencedId)
+
+    traversal_function = create_default_traversal_function()
+
+    for traversal_item in traversal_function.traverse(root_object):
+        obj = traversal_item.current
+
+        if not hasattr(obj, "id"):
+            continue
+
+        if obj.id == target_id:
+            return obj
+
+        if hasattr(obj, "applicationId"):
+            app_id = obj.applicationId
+            if app_id == target_id:
+                return obj
+
+    def deep_search(search_obj):
+        if hasattr(search_obj, "id") and search_obj.id == target_id:
+            return search_obj
+
+        elements_attrs = ["elements", "@elements"]
+        for attr in elements_attrs:
+            if hasattr(search_obj, attr):
+                elements = getattr(search_obj, attr)
+                if elements and isinstance(elements, list):
+                    for element in elements:
+                        if hasattr(element, "id") and element.id == target_id:
+                            return element
+                        if (
+                            hasattr(element, "referencedId")
+                            and element.referencedId == target_id
+                        ):
+                            ref_obj = find_object_by_id(
+                                root_object, element.referencedId
+                            )
+                            if ref_obj:
+                                return ref_obj
+                        result = deep_search(element)
+                        if result:
+                            return result
+        return None
+
+    return deep_search(root_object)

bpy_speckle/functions.py

@@ -1,104 +0,0 @@
-from specklepy.api.client import SpeckleClient
-from bpy_speckle.clients import speckle_clients
-
-"""
-Speckle functions
-"""
-
-unit_scale = {
-    "meters": 1.0,
-    "centimeters": 0.01,
-    "millimeters": 0.001,
-    "inches": 0.0254,
-    "feet": 0.3048,
-    "kilometers": 1000.0,
-    "mm": 0.001,
-    "cm": 0.01,
-    "m": 1.0,
-    "km": 1000.0,
-    "in": 0.0254,
-    "ft": 0.3048,
-    "yd": 0.9144,
-    "mi": 1609.340,
-}
-
-"""
-Utility functions
-"""
-
-
-def _report(msg):
-    """
-    Function for printing messages to the console
-    """
-    print("SpeckleBlender: {}".format(msg))
-
-
-def get_scale_length(units):
-    if units.lower() in unit_scale.keys():
-        return unit_scale[units]
-    _report("Units <{}> are not supported.".format(units))
-    return 1.0
-
-
-"""
-Client, user, and stream functions
-"""
-
-
-def _check_speckle_client_user_stream(scene):
-    """
-    Verify that there is a valid user and stream
-    """
-    speckle = scene.speckle
-
-    user = (
-        speckle.users[int(speckle.active_user)]
-        if len(speckle.users) > int(speckle.active_user)
-        else None
-    )
-
-    if user is None:
-        print("No users loaded.")
-
-    stream = (
-        user.streams[user.active_stream]
-        if len(user.streams) > user.active_stream
-        else None
-    )
-
-    if stream is None:
-        print("Account contains no streams.")
-
-    return (user, stream)
-
-
-def _create_stream(user, stream_name, units="Millimeters"):
-    """
-    Create a new stream
-    """
-
-    # TODO: double-check, but this should not be accessible through the UI if
-    # there aren't any active users anyway
-    # user = context.scene.speckle.users[int(context.scene.speckle.active_user)]
-    client = speckle_clients[int(bpy.context.scene.speckle.active_user)]
-    return client.stream.create(
-        name=stream_name, description="This is a Blender stream.", is_public=True
-    )
-
-    # TODO: Update stream with properties such as units, etc.
-
-
-def _delete_stream(client, user, stream):
-    """
-    Delete the active stream
-    TODO: probably doesn't need to be a separate function and can be
-    folded into the operator
-    """
-
-    user = context.scene.speckle.users[int(context.scene.speckle.active_user)]
-    client = speckle_clients[int(context.scene.speckle.active_user)]
-
-    if stream:
-        res = client.streams.delete(stream.id)
-        _report(res["message"])

bpy_speckle/install_dependencies.py

@@ -1,104 +0,0 @@
-import os, sys, bpy
-import ctypes, sys
-
-import os, sys
-
-
-def modules_path():
-    # set up addons/modules under the user
-    # script path. Here we'll install the
-    # dependencies
-    modulespath = os.path.normpath(
-        os.path.join(bpy.utils.script_path_user(), "addons", "modules")
-    )
-    if not os.path.exists(modulespath):
-        os.makedirs(modulespath)
-
-    # set user modules path at beginning of paths for earlier hit
-    if sys.path[1] != modulespath:
-        sys.path.insert(1, modulespath)
-
-    return modulespath
-
-
-def install_dependencies():
-    import sys
-    import os
-
-    try:
-        try:
-            import pip
-        except:
-            print("Installing pip... "),
-            from subprocess import run as sprun
-
-            res = sprun([bpy.app.binary_path_python, "-m", "ensurepip"])
-
-            if res.returncode == 0:
-                import pip
-            else:
-                raise Exception("Failed to install pip.")
-
-        modulespath = modules_path()
-
-        if not os.path.exists(modulespath):
-            os.makedirs(modulespath)
-
-        print("Installing speckle to {}... ".format(modulespath)),
-        from subprocess import run as sprun
-
-        res = sprun(
-            [
-                bpy.app.binary_path_python,
-                "-m",
-                "pip",
-                "install",
-                "-q",
-                "-t",
-                "{}".format(modulespath),
-                "--no-deps",
-                "pydantic",
-            ]
-        )
-        res = sprun(
-            [
-                bpy.app.binary_path_python,
-                "-m",
-                "pip",
-                "install",
-                "-q",
-                "-t",
-                "{}".format(modulespath),
-                "specklepy",
-            ]
-        )
-
-    except:
-        raise Exception(
-            "Failed to install dependencies. Please make sure you have pip installed."
-        )
-
-
-if __name__ == "__main__":
-    try:
-        import specklepy
-    except:
-        print("Failed to load speckle.")
-        from sys import platform
-
-        if platform == "win32":
-            if ctypes.windll.shell32.IsUserAnAdmin():
-                install_dependencies()
-                import specklepy
-            else:
-                ctypes.windll.shell32.ShellExecuteW(
-                    None, "runas", sys.executable, __file__, None, 1
-                )
-
-        else:
-            print(
-                "Platform {} cannot automatically install dependencies.".format(
-                    platform
-                )
-            )
-            raise

bpy_speckle/installer.py

@@ -0,0 +1,246 @@
+"""
+Provides uniform and consistent path helpers for `specklepy`
+"""
+import os
+import sys
+from pathlib import Path
+from typing import Optional
+from importlib import import_module, invalidate_caches
+
+_user_data_env_var = "SPECKLE_USERDATA_PATH"
+
+
+def _path() -> Optional[Path]:
+    """Read the user data path override setting."""
+    path_override = os.environ.get(_user_data_env_var)
+    if path_override:
+        return Path(path_override)
+    return None
+
+
+_application_name = "Speckle"
+
+
+def override_application_name(application_name: str) -> None:
+    """Override the global Speckle application name."""
+    global _application_name
+    _application_name = application_name
+
+
+def override_application_data_path(path: Optional[str]) -> None:
+    """
+    Override the global Speckle application data path.
+
+    If the value of path is `None` the environment variable gets deleted.
+    """
+    if path:
+        os.environ[_user_data_env_var] = path
+    else:
+        os.environ.pop(_user_data_env_var, None)
+
+
+def _ensure_folder_exists(base_path: Path, folder_name: str) -> Path:
+    path = base_path.joinpath(folder_name)
+    path.mkdir(exist_ok=True, parents=True)
+    return path
+
+
+def user_application_data_path() -> Path:
+    """Get the platform specific user configuration folder path"""
+    path_override = _path()
+    if path_override:
+        return path_override
+
+    try:
+        if sys.platform.startswith("win"):
+            app_data_path = os.getenv("APPDATA")
+            if not app_data_path:
+                raise Exception(
+                    "Cannot get appdata path from environment."
+                )
+            return Path(app_data_path)
+        else:
+            # try getting the standard XDG_DATA_HOME value
+            # as that is used as an override
+            app_data_path = os.getenv("XDG_DATA_HOME")
+            if app_data_path:
+                return Path(app_data_path)
+            else:
+                return _ensure_folder_exists(Path.home(), ".config")
+    except Exception as ex:
+        raise Exception(
+            "Failed to initialize user application data path.", ex
+        )
+
+
+def user_speckle_folder_path() -> Path:
+    """Get the folder where the user's Speckle data should be stored."""
+    return _ensure_folder_exists(user_application_data_path(), _application_name)
+
+
+def user_speckle_connector_installation_path(host_application: str) -> Path:
+    """
+    Gets a connector specific installation folder.
+
+    In this folder we can put our connector installation and all python packages.
+    """
+    return _ensure_folder_exists(
+        _ensure_folder_exists(user_speckle_folder_path(), "connector_installations"),
+        host_application,
+    )
+
+
+
+
+
+
+print("Starting module dependency installation")
+print(sys.executable)
+
+PYTHON_PATH = sys.executable
+
+
+
+def connector_installation_path(host_application: str) -> Path:
+    connector_installation_path = user_speckle_connector_installation_path(host_application)
+    connector_installation_path.mkdir(exist_ok=True, parents=True)
+
+    # set user modules path at beginning of paths for earlier hit
+    if sys.path[0] != connector_installation_path:
+        sys.path.insert(0, str(connector_installation_path))
+
+    print(f"Using connector installation path {connector_installation_path}")
+    return connector_installation_path
+
+
+
+def is_pip_available() -> bool:
+    try:
+        import_module("pip")  # noqa F401
+        return True
+    except ImportError:
+        return False
+
+
+def ensure_pip() -> None:
+    print("Installing pip... ")
+
+    from subprocess import run
+
+    completed_process = run([PYTHON_PATH, "-m", "ensurepip"])
+
+    if completed_process.returncode == 0:
+        print("Successfully installed pip")
+    else:
+        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")
+    return path
+
+
+def install_requirements(host_application: str) -> None:
+    # set up addons/modules under the user
+    # script path. Here we'll install the
+    # dependencies
+    path = connector_installation_path(host_application)
+
+    from subprocess import run
+
+    def debugger_is_active() -> bool:
+        """Return if the debugger is currently active"""
+        return hasattr(sys, 'gettrace') and sys.gettrace() is not None
+    
+    requirements_path = get_requirements_path()
+
+    is_debug = debugger_is_active()
+    
+    if not is_debug and not requirements_path.exists():
+        print("Skipped installing dependencies")
+        return
+
+    print(f"Installing Speckle dependencies to {path}")
+    completed_process = run(
+        [
+            PYTHON_PATH,
+            "-m",
+            "uv",
+            "pip",
+            "install",
+            "--system",
+            "--target",
+            str(path),
+            "-r",
+            str(requirements_path),
+        ],
+        capture_output=True,
+        text=True,
+    )
+
+    if completed_process.returncode != 0:
+        m = f"Failed to install dependencies through uv, got {completed_process.returncode} return code"
+        print(m)
+        raise Exception(m)
+    
+    print("Successfully installed dependencies")
+
+    if not is_debug:
+        requirements_path.unlink()
+
+
+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)
+
+
+def _import_dependencies() -> None:
+    import_module("specklepy")
+    # the code above doesn't work for now, it fails on importing graphql-core
+    # despite that, the connector seams to be working as expected
+    # But it would be nice to make this solution work
+    # it would ensure that all dependencies are fully loaded  
+    # requirements = get_requirements_path().read_text()
+    # reqs = [
+    #     req.split(" ; ")[0].split("==")[0].split("[")[0].replace("-", "_")
+    #     for req in requirements.split("\n")
+    #     if req and not req.startswith(" ")
+    # ]
+    # for req in reqs:
+    #     print(req)
+    #     import_module("specklepy")
+
+def ensure_dependencies(host_application: str) -> None:
+    try:
+        install_dependencies(host_application)
+        invalidate_caches()
+        _import_dependencies()
+        print("Successfully found dependencies")
+    except ImportError:
+        raise Exception(f"Cannot automatically ensure Speckle dependencies. Please try restarting the host application {host_application}!")
+
+

bpy_speckle/operators/__init__.py

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

bpy_speckle/operators/commit.py

@@ -1,85 +0,0 @@
-"""
-Commit operators
-"""
-import bpy, os
-from bpy.props import (
-    StringProperty,
-    BoolProperty,
-    FloatProperty,
-    CollectionProperty,
-    EnumProperty,
-)
-
-from bpy_speckle.functions import (
-    _check_speckle_client_user_stream,
-    _create_stream,
-    get_scale_length,
-    _report,
-)
-
-from bpy_speckle.convert import from_speckle_object
-from bpy_speckle.clients import speckle_clients
-
-
-class DeleteCommit(bpy.types.Operator):
-    """
-    Delete stream
-    """
-
-    bl_idname = "speckle.delete_commit"
-    bl_label = "Delete commit"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Delete active commit permanently"
-
-    are_you_sure: BoolProperty(
-        name="Confirm", default=False,
-    )
-
-    def draw(self, context):
-        layout = self.layout
-        col = layout.column()
-        col.prop(self, "are_you_sure")
-
-    def invoke(self, context, event):
-        wm = context.window_manager
-        if len(context.scene.speckle.users) > 0:
-            return wm.invoke_props_dialog(self)
-
-        return {"CANCELLED"}
-
-    def execute(self, context):
-
-        if not self.are_you_sure:
-            return {"CANCELLED"}
-
-        self.are_you_sure = False
-
-        speckle = context.scene.speckle
-
-        check = _check_speckle_client_user_stream(context.scene)
-        if check is None:
-            return {"CANCELLED"}
-
-        user, stream = check
-        client = speckle_clients[int(context.scene.speckle.active_user)]
-
-        stream = user.streams[user.active_stream]
-        if len(stream.branches) < 1:
-            return {"CANCELLED"}
-        else:
-            branch = stream.branches[int(stream.branch)]
-            if len(branch.commits) < 1:
-                return {"CANCELLED"}
-            else:
-                commit = branch.commits[int(branch.commit)]
-
-                deleted = client.commit.delete(stream_id=stream.id, commit_id=commit.id)
-
-        return {"FINISHED"}
-
-        bpy.ops.speckle.load_user_streams()
-        context.view_layer.update()
-
-        if context.area:
-            context.area.tag_redraw()
-        return {"FINISHED"}

bpy_speckle/operators/misc.py

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

bpy_speckle/operators/object.py

@@ -1,384 +0,0 @@
-"""
-Object operators
-"""
-
-import bpy, bmesh, os
-from bpy.props import (
-    StringProperty,
-    BoolProperty,
-    FloatProperty,
-    CollectionProperty,
-    EnumProperty,
-)
-
-from specklepy.api.client import SpeckleClient
-from bpy_speckle.convert import to_speckle_object
-from bpy_speckle.convert.to_speckle import export_ngons_as_polylines
-
-from bpy_speckle.functions import get_scale_length, _report
-from bpy_speckle.clients import speckle_clients
-
-
-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"
-    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)]
-        stream = user.streams[user.active_stream]
-
-        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 = to_speckle_object(active, scale)
-
-                _report("Updating object {}".format(sm["_id"]))
-                client.objects.update(active.speckle.object_id, sm)
-
-                return {"FINISHED"}
-
-            return {"CANCELLED"}
-        return {"CANCELLED"}
-
-
-class ResetObject(bpy.types.Operator):
-    """
-    Reset Speckle object settings
-    """
-
-    bl_idname = "speckle.reset_object"
-    bl_label = "Reset Object"
-    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()
-
-        return {"FINISHED"}
-
-
-class DeleteObject(bpy.types.Operator):
-    """
-    Delete object from the server and update relevant stream
-    """
-
-    bl_idname = "speckle.delete_object"
-    bl_label = "Delete Object"
-    bl_options = {"REGISTER", "UNDO"}
-
-    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.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"}
-            # print("Existing: %s" % SpeckleResource.to_json_pretty(existing))
-            new_objects = [
-                x
-                for x in res["resource"]["objects"]
-                if x["_id"] != active.speckle.object_id
-            ]
-            # print (SpeckleResource.to_json_pretty(new_objects))
-
-            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()
-
-        return {"FINISHED"}
-
-
-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"
-    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
-            )
-
-            sp = export_ngons_as_polylines(active, scale)
-
-            if sp is None:
-                return {"CANCELLED"}
-
-            placeholders = []
-            for polyline in sp:
-
-                res = client.objects.create([polyline])
-                print(res)
-
-                if res is None:
-                    _report(client.me)
-                    continue
-                placeholders.extend(res)
-
-                # polyline['_id'] = res['_id']
-                # placeholders.append({'type':'Placeholder', '_id':res['_id']})
-
-            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.")
-
-        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")
-
-
-class UploadObject(bpy.types.Operator):
-    """
-    DEPRECATED
-    Upload an individual object
-    """
-
-    bl_idname = "speckle.upload_object"
-    bl_label = "Upload Object"
-    bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context):
-
-        active = context.active_object
-        if active is not None:
-            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
-            )
-
-            sm = to_speckle_object(active, scale)
-
-            placeholders = client.objects.create([sm])
-            if placeholders is None:
-                return {"CANCELLED"}
-
-            sstream = client.streams.get(stream.id)
-            sstream.objects.extend(placeholders)
-
-            N = sstream.layers[-1].objectCount
-            sstream.layers[-1].objectCount = N + 1
-            sstream.layers[-1].topology = "0-%s" % (N + 1)
-
-            _report("Updating stream %s" % stream.id)
-
-            res = client.streams.update(stream["id"], sstream)
-
-            _report(res)
-
-            active.speckle.enabled = True
-            active.speckle.object_id = sm.id
-            active.speckle.stream_id = stream.id
-            active.speckle.send_or_receive = "send"
-
-            context.view_layer.update()
-            _report("Done.")
-
-        return {"FINISHED"}
-
-
-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()]
-
-
-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"
-    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)
-
-        return {"FINISHED"}
-
-
-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"
-    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)
-
-        return {"FINISHED"}

bpy_speckle/operators/streams.py

@@ -1,814 +0,0 @@
-"""
-Stream operators
-"""
-from itertools import chain
-from typing import Dict
-import bpy, bmesh, os
-from specklepy.api.models import Commit
-import webbrowser
-from bpy.props import (
-    StringProperty,
-    BoolProperty,
-    FloatProperty,
-    CollectionProperty,
-    EnumProperty,
-)
-from bpy_speckle.functions import (
-    _check_speckle_client_user_stream,
-    _create_stream,
-    get_scale_length,
-    _report,
-)
-from bpy_speckle.convert import to_speckle_object, get_speckle_subobjects
-from bpy_speckle.convert.to_speckle import export_ngons_as_polylines
-
-from bpy_speckle.convert import from_speckle_object
-from bpy_speckle.clients import speckle_clients
-from bpy_speckle.operators.users import add_user_stream
-
-from specklepy.api import operations
-from specklepy.api.credentials import StreamWrapper
-from specklepy.api.resources.stream import Stream
-from specklepy.transports.server import ServerTransport
-from specklepy.objects import Base
-from specklepy.objects.geometry import *
-from specklepy.logging.exceptions import SpeckleException
-
-
-def get_objects_collections(base) -> Dict:
-    """Create collections based on the dynamic members on a root commit object"""
-    collections = {}
-    for name in base.get_dynamic_member_names():
-        value = base[name]
-        if isinstance(value, list):
-            col = create_collection(name)
-            collections[name] = get_objects_nested_lists(value, col)
-        if isinstance(value, Base):
-            col = create_collection(name)
-            collections[name] = get_objects_collections_recursive(value, col)
-
-    return collections
-
-
-def get_objects_nested_lists(items, parent_col=None) -> List:
-    """For handling the weird nested lists that come from Grasshopper"""
-    objects = []
-
-    if isinstance(items[0], list):
-        items = list(chain.from_iterable(items))
-        objects.extend(get_objects_nested_lists(items, parent_col))
-    else:
-        objects = [
-            get_objects_collections_recursive(item, parent_col)
-            for item in items
-            if isinstance(item, Base)
-        ]
-
-    return objects
-
-
-def get_objects_collections_recursive(base, parent_col=None) -> List:
-    """Recursively create collections based on the dynamic members on nested `Base` objects within the root commit object"""
-    # if it's a convertable (registered) class and not just a plain `Base`, return the object itself
-    object_type = Base.get_registered_type(base.speckle_type)
-    if (
-        (object_type and object_type != Base)
-        or hasattr(base, "displayMesh")
-        or hasattr(base, "displayValue")
-    ):
-        return [base]
-
-    # if it's an unknown type, try to drill further down to find convertable objects
-    objects = []
-
-    for name in base.get_dynamic_member_names():
-        value = base[name]
-        if isinstance(value, list):
-            for item in value:
-                if isinstance(item, Base):
-                    objects.append(item)
-        if isinstance(value, Base):
-            col = parent_col.children.get(name)
-            if not parent_col.children.get(name):
-                col = create_collection(name)
-                parent_col.children.link(col)
-            objects.append({name: get_objects_collections_recursive(value, col)})
-
-    return objects
-
-
-def bases_to_native(context, collections, scale, stream_id, func=None):
-    for col_name, objects in collections.items():
-        col = bpy.data.collections[col_name]
-        existing = get_existing_collection_objs(col)
-        if isinstance(objects, dict):
-            bases_to_native(context, objects, scale, stream_id)
-        elif isinstance(objects, list):
-            for obj in objects:
-                if isinstance(obj, dict):
-                    bases_to_native(context, obj, scale, stream_id, func)
-                elif isinstance(obj, list):
-                    for item in obj:
-                        if isinstance(item, dict):
-                            bases_to_native(context, item, scale, stream_id, func)
-                        elif isinstance(item, Base):
-                            base_to_native(
-                                context, item, scale, stream_id, col, existing, func
-                            )
-                elif isinstance(obj, Base):
-                    base_to_native(context, obj, scale, stream_id, col, existing, func)
-                else:
-                    _report(
-                        f"Something went wrong when receiving collection: {col_name}"
-                    )
-
-            bpy.context.view_layer.update()
-
-            if context.area:
-                context.area.tag_redraw()
-
-
-def base_to_native(context, base, scale, stream_id, col, existing, func=None):
-    new_objects = [from_speckle_object(base, scale)]
-
-    if hasattr(base, "properties") and base.properties is not None:
-        new_objects.extend(get_speckle_subobjects(base.properties, scale, base.id))
-    elif isinstance(base, dict) and "properties" in base.keys():
-        new_objects.extend(
-            get_speckle_subobjects(base["properties"], scale, base["id"])
-        )
-
-    """
-    Set object Speckle settings
-    """
-    for new_object in new_objects:
-        if new_object is None:
-            continue
-
-        """
-        Run injected function
-        """
-        if func:
-            new_object = func(context.scene, new_object)
-
-        if (
-            new_object is None
-        ):  # Make sure that the injected function returned an object
-            new_obj = new_object
-            _report("Script '{}' returned None.".format(func.__module__))
-            continue
-
-        new_object.speckle.stream_id = stream_id
-        new_object.speckle.send_or_receive = "receive"
-
-        if new_object.speckle.object_id in existing.keys():
-            name = existing[new_object.speckle.object_id].name
-            existing[new_object.speckle.object_id].name = name + "__deleted"
-            new_object.name = name
-            col.objects.unlink(existing[new_object.speckle.object_id])
-
-        if new_object.name not in col.objects:
-            col.objects.link(new_object)
-
-
-def create_collection(name, clear_collection=True):
-    if name in bpy.data.collections:
-        col = bpy.data.collections[name]
-        if clear_collection:
-            for obj in col.objects:
-                col.objects.unlink(obj)
-    else:
-        col = bpy.data.collections.new(name)
-
-    return col
-
-
-def create_child_collections(parent_col, children_names):
-    for name in children_names:
-        col = create_collection(name)
-        parent_col.children.link(col)
-
-
-def get_existing_collection_objs(col):
-    return {
-        obj.speckle.object_id: obj for obj in col.objects if obj.speckle.object_id != ""
-    }
-
-
-def get_collection_parents(collection, names):
-    for parent in bpy.data.collections:
-        if collection.name in parent.children.keys():
-            # TODO: this should be rethought to make it clear when this is an IFC delim so we know to replace it
-            # with `/` again on receive
-            names.append(parent.name.replace("/", "::").replace(".", "::"))
-            get_collection_parents(parent, names)
-
-
-def get_collection_hierarchy(collection):
-    if not collection:
-        return []
-    names = [collection.name.replace("/", "::").replace(".", "::")]
-    get_collection_parents(collection, names)
-
-    return names
-
-
-def create_nested_hierarchy(base, hierarchy, objects):
-    child = base
-
-    while hierarchy:
-        name = hierarchy.pop()
-        if not hasattr(child, name):
-            child[name] = Base()
-            child.add_detachable_attrs({name})
-        child = child[name]
-
-    # TODO: what do we call this attribute?
-    if not hasattr(child, "objects"):
-        child["objects"] = []
-    child["objects"].extend(objects)
-
-    return base
-
-
-class ReceiveStreamObjects(bpy.types.Operator):
-    """
-    Receive stream objects
-    """
-
-    bl_idname = "speckle.receive_stream_objects"
-    bl_label = "Download Stream Objects"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Receive objects from active stream"
-
-    def execute(self, context):
-        bpy.context.view_layer.objects.active = None
-
-        check = _check_speckle_client_user_stream(context.scene)
-        if check is None:
-            return {"CANCELLED"}
-
-        user, bstream = check
-
-        client = speckle_clients[int(context.scene.speckle.active_user)]
-
-        stream = client.stream.get(id=bstream.id)
-        if stream.branches.totalCount < 1:
-            return {"CANCELLED"}
-
-        if not stream.branches:
-            return {"CANCELLED"}
-
-        branch = stream.branches.items[int(bstream.branch)]
-
-        bbranch = bstream.branches[int(bstream.branch)]
-
-        if branch.commits.totalCount < 1:
-            print("No commits found. Probably an empty stream.")
-            return {"CANCELLED"}
-
-        commit = branch.commits.items[int(bbranch.commit)]
-
-        transport = ServerTransport(stream.id, client)
-        stream_data = operations.receive(commit.referencedObject, transport)
-        client.commit.received(
-            bstream.id,
-            commit.id,
-            source_application="blender",
-            message="received commit from Speckle Blender",
-        )
-
-        """
-        Create or get Collection for stream objects
-        """
-        collections = get_objects_collections(stream_data)
-
-        if not collections:
-            return {"CANCELLED"}
-
-        name = "{} [ {} @ {} ]".format(stream.name, branch.name, commit.id)
-        col = create_collection(name)
-        col.speckle.stream_id = stream.id
-        col.speckle.name = stream.name
-        col.speckle.units = stream_data.units
-        if col.name not in bpy.context.scene.collection.children:
-            bpy.context.scene.collection.children.link(col)
-
-        for child_col in collections.keys():
-            try:
-                col.children.link(bpy.data.collections[child_col])
-            except:
-                pass
-        """
-        Set conversion scale from stream units
-        """
-        scale = (
-            get_scale_length(stream_data.units)
-            / context.scene.unit_settings.scale_length
-        )
-
-        """
-        Get script from text editor for injection
-        """
-        func = None
-        if context.scene.speckle.receive_script in bpy.data.texts:
-            mod = bpy.data.texts[context.scene.speckle.receive_script].as_module()
-            if hasattr(mod, "execute"):
-                func = mod.execute
-
-        """
-        Iterate through retrieved resources
-        """
-        bases_to_native(context, collections, scale, stream.id, func)
-
-        return {"FINISHED"}
-
-
-class SendStreamObjects(bpy.types.Operator):
-    """
-    Send stream objects
-    """
-
-    bl_idname = "speckle.send_stream_objects"
-    bl_label = "Send stream objects"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Send selected objects to active stream"
-
-    apply_modifiers: BoolProperty(name="Apply modifiers", default=True)
-    commit_message: StringProperty(
-        name="Message",
-        default="Pushed elements from Blender.",
-    )
-
-    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
-        if len(context.scene.speckle.users) > 0:
-            N = len(context.selected_objects)
-            if N == 1:
-                self.commit_message = "Pushed {} element from Blender.".format(N)
-            else:
-                self.commit_message = "Pushed {} elements from Blender.".format(N)
-            return wm.invoke_props_dialog(self)
-
-        return {"CANCELLED"}
-
-    def execute(self, context):
-
-        selected = context.selected_objects
-
-        if len(selected) < 1:
-            return {"CANCELLED"}
-
-        check = _check_speckle_client_user_stream(context.scene)
-        if check is None:
-            return {"CANCELLED"}
-
-        user, bstream = check
-        stream = user.streams[user.active_stream]
-        branch = stream.branches[int(stream.branch)]
-
-        client = speckle_clients[int(context.scene.speckle.active_user)]
-
-        scale = context.scene.unit_settings.scale_length / get_scale_length(
-            stream.units.lower()
-        )
-
-        """
-        Get script from text editor for injection
-        """
-        func = None
-        if context.scene.speckle.send_script in bpy.data.texts:
-            mod = bpy.data.texts[context.scene.speckle.send_script].as_module()
-            if hasattr(mod, "execute"):
-                func = mod.execute
-
-        export = {}
-
-        for obj in selected:
-
-            # if obj.type != 'MESH':
-            #     continue
-
-            new_object = obj
-
-            """
-            Run injected function
-            """
-            if func:
-                new_object = func(context.scene, obj)
-
-                if (
-                    new_object is None
-                ):  # Make sure that the injected function returned an object
-                    new_obj = obj
-                    _report("Script '{}' returned None.".format(func.__module__))
-                    continue
-
-            _report("Converting {}".format(obj.name))
-
-            ngons = obj.get("speckle_ngons_as_polylines", False)
-
-            if ngons:
-                converted = export_ngons_as_polylines(obj, scale)
-            else:
-                converted = to_speckle_object(
-                    obj,
-                    scale,
-                    bpy.context.evaluated_depsgraph_get()
-                    if self.apply_modifiers
-                    else None,
-                )
-
-            if not converted:
-                continue
-
-            collection_name = obj.users_collection[0].name
-            if not export.get(collection_name):
-                export[collection_name] = []
-
-            export[collection_name].extend(converted)
-
-        base = Base()
-        for name, objects in export.items():
-            collection = bpy.data.collections.get(name)
-            hierarchy = get_collection_hierarchy(collection)
-            create_nested_hierarchy(base, hierarchy, objects)
-
-        transport = ServerTransport(stream.id, client)
-
-        obj_id = operations.send(
-            base,
-            [transport],
-        )
-        client.commit.create(
-            stream.id,
-            obj_id,
-            branch.name,
-            message=self.commit_message,
-            source_application="blender",
-        )
-
-        bpy.ops.speckle.load_user_streams()
-
-        context.view_layer.update()
-
-        if context.area:
-            context.area.tag_redraw()
-        return {"FINISHED"}
-
-
-class ViewStreamDataApi(bpy.types.Operator):
-    bl_idname = "speckle.view_stream_data_api"
-    bl_label = "Open Stream in Web"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "View the stream in the web browser"
-
-    def execute(self, context):
-
-        if len(context.scene.speckle.users) > 0:
-            user = context.scene.speckle.users[int(context.scene.speckle.active_user)]
-            if len(user.streams) > 0:
-                stream = user.streams[user.active_stream]
-
-                webbrowser.open("%s/streams/%s" % (user.server_url, stream.id), new=2)
-                return {"FINISHED"}
-        return {"CANCELLED"}
-
-
-class AddStreamFromURL(bpy.types.Operator):
-    """
-    Add / select a stream using its url
-    """
-
-    bl_idname = "speckle.add_stream_from_url"
-    bl_label = "Add stream from URL"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Add an existing stream by providing its URL"
-    stream_url: StringProperty(
-        name="Stream URL", default="https://speckle.xyz/streams/3073b96e86"
-    )
-
-    def draw(self, context):
-        layout = self.layout
-        col = layout.column()
-        col.prop(self, "stream_url")
-
-    def invoke(self, context, event):
-        wm = context.window_manager
-        if len(context.scene.speckle.users) > 0:
-            return wm.invoke_props_dialog(self)
-
-        return {"CANCELLED"}
-
-    def execute(self, context):
-        speckle = context.scene.speckle
-
-        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:
-            return {"CANCELLED"}
-        speckle.active_user = str(user_index)
-        user = speckle.users[user_index]
-
-        client = speckle_clients[user_index]
-        stream = client.stream.get(wrapper.stream_id)
-        if not isinstance(stream, Stream):
-            raise SpeckleException("Could not get the requested stream")
-
-        index, b_stream = next(
-            ((i, s) for i, s in enumerate(user.streams) if s.id == stream.id),
-            (None, None),
-        )
-
-        if index is None:
-            add_user_stream(user, stream)
-            user.active_stream, b_stream = next(
-                (i, s) for i, s in enumerate(user.streams) if s.id == stream.id
-            )
-        else:
-            user.active_stream = index
-
-        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()
-
-        return {"FINISHED"}
-
-
-class CreateStream(bpy.types.Operator):
-    """
-    Create new stream
-    """
-
-    bl_idname = "speckle.create_stream"
-    bl_label = "Create stream"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Create new stream"
-
-    stream_name: StringProperty(name="Stream name", default="SpeckleStream")
-    stream_description: StringProperty(
-        name="Stream description", default="This is a Blender stream."
-    )
-
-    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
-        if len(context.scene.speckle.users) > 0:
-            return wm.invoke_props_dialog(self)
-
-        return {"CANCELLED"}
-
-    def execute(self, context):
-
-        check = _check_speckle_client_user_stream(context.scene)
-        if check is None:
-            return {"CANCELLED"}
-
-        user, bstream = check
-
-        client = speckle_clients[int(context.scene.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()
-
-        return {"FINISHED"}
-
-
-class DeleteStream(bpy.types.Operator):
-    """
-    Delete stream
-    """
-
-    bl_idname = "speckle.delete_stream"
-    bl_label = "Delete stream"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Delete selected stream permanently"
-
-    are_you_sure: BoolProperty(
-        name="Confirm",
-        default=False,
-    )
-
-    delete_collection: BoolProperty(name="Delete collection", default=False)
-
-    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
-        if len(context.scene.speckle.users) > 0:
-            return wm.invoke_props_dialog(self)
-
-        return {"CANCELLED"}
-
-    def execute(self, context):
-
-        if not self.are_you_sure:
-            return {"CANCELLED"}
-
-        self.are_you_sure = False
-
-        check = _check_speckle_client_user_stream(context.scene)
-        if check is None:
-            return {"CANCELLED"}
-
-        user, stream = check
-        client = speckle_clients[int(context.scene.speckle.active_user)]
-
-        client.stream.delete(id=stream.id)
-
-        if self.delete_collection:
-            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()
-        return {"FINISHED"}
-
-
-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
-
-        return {"FINISHED"}
-
-
-class UpdateGlobal(bpy.types.Operator):
-    """
-    DEPRECATED
-    Update all Speckle objects
-    """
-
-    bl_idname = "speckle.update_global"
-    bl_label = "Update Global"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Update all Speckle objects"
-
-    client = None
-
-    def draw(self, context):
-        layout = self.layout
-        row = layout.row()
-        label = row.label(text="Update everything.")
-
-    def execute(self, context):
-
-        client = context.scene.speckle.client
-
-        profiles = client.load_local_profiles()
-        if len(profiles) < 1:
-            raise ValueError("No profiles found.")
-        client.use_existing_profile(sorted(profiles.keys())[0])
-        context.scene.speckle.user = sorted(profiles.keys())[0]
-
-        for obj in context.scene.objects:
-            if obj.speckle.enabled:
-                UpdateObject(context.scene.speckle_client, obj)
-
-        context.scene.update()
-        return {"FINISHED"}
-
-
-class CopyStreamId(bpy.types.Operator):
-    """
-    Copy stream ID to clipboard
-    """
-
-    bl_idname = "speckle.stream_copy_id"
-    bl_label = "Copy stream ID"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Copy stream ID to clipboard"
-
-    def execute(self, context):
-        speckle = context.scene.speckle
-
-        if len(speckle.users) < 1:
-            return {"CANCELLED"}
-        user = speckle.users[int(speckle.active_user)]
-        if len(user.streams) < 1:
-            return {"CANCELLED"}
-        stream = user.streams[user.active_stream]
-        bpy.context.window_manager.clipboard = stream.id
-        return {"FINISHED"}
-
-
-class CopyCommitId(bpy.types.Operator):
-    """
-    Copy commit ID to clipboard
-    """
-
-    bl_idname = "speckle.commit_copy_id"
-    bl_label = "Copy commit ID"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Copy commit ID to clipboard"
-
-    def execute(self, context):
-        speckle = context.scene.speckle
-
-        if len(speckle.users) < 1:
-            return {"CANCELLED"}
-        user = speckle.users[int(speckle.active_user)]
-        if len(user.streams) < 1:
-            return {"CANCELLED"}
-        stream = user.streams[user.active_stream]
-        if len(stream.branches) < 1:
-            return {"CANCELLED"}
-        branch = stream.branches[int(stream.branch)]
-        if len(branch.commits) < 1:
-            return {"CANCELLED"}
-        commit = branch.commits[int(branch.commit)]
-        bpy.context.window_manager.clipboard = commit.id
-        return {"FINISHED"}
-
-
-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):
-        speckle = context.scene.speckle
-
-        if len(speckle.users) < 1:
-            return {"CANCELLED"}
-        user = speckle.users[int(speckle.active_user)]
-        if len(user.streams) < 1:
-            return {"CANCELLED"}
-        stream = user.streams[user.active_stream]
-        if len(stream.branches) < 1:
-            return {"CANCELLED"}
-        branch = stream.branches[int(stream.branch)]
-        bpy.context.window_manager.clipboard = branch.name
-        return {"FINISHED"}

bpy_speckle/operators/users.py

@@ -1,145 +0,0 @@
-"""
-User account operators
-"""
-
-from typing import cast
-import bpy, bmesh, os
-from bpy.props import (
-    StringProperty,
-    BoolProperty,
-    FloatProperty,
-    CollectionProperty,
-    EnumProperty,
-)
-from bpy_speckle.properties.scene import SpeckleUserObject
-
-from bpy_speckle.functions import _report
-from bpy_speckle.clients import speckle_clients
-
-from specklepy.api.client import SpeckleClient
-from specklepy.api.credentials import get_default_account, get_local_accounts
-
-
-class LoadUsers(bpy.types.Operator):
-    """
-    Load all users from local user database
-    """
-
-    bl_idname = "speckle.users_load"
-    bl_label = "Load users"
-    bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context):
-
-        _report("Loading users...")
-
-        users = context.scene.speckle.users
-
-        context.scene.speckle.users.clear()
-        speckle_clients.clear()
-
-        profiles = get_local_accounts()
-
-        for profile in profiles:
-            user = users.add()
-            user.server_name = profile.serverInfo.name or "Speckle Server"
-            user.server_url = profile.serverInfo.url
-            user.name = profile.userInfo.name
-            user.email = profile.userInfo.email
-            user.company = profile.userInfo.company or ""
-            user.authToken = profile.token
-            try:
-                client = SpeckleClient(
-                    host=profile.serverInfo.url,
-                    use_ssl="https" in profile.serverInfo.url,
-                )
-                client.authenticate(user.authToken)
-                speckle_clients.append(client)
-            except Exception as ex:
-                _report(ex)
-                users.remove(len(users) - 1)
-            if profile.isDefault:
-                context.scene.speckle.active_user = str(len(users) - 1)
-
-        context.scene.speckle.active_user_index = int(context.scene.speckle.active_user)
-        bpy.ops.speckle.load_user_streams()
-        bpy.context.view_layer.update()
-
-        if context.area:
-            context.area.tag_redraw()
-        return {"FINISHED"}
-
-
-def add_user_stream(user, stream):
-    s = user.streams.add()
-    s.name = stream.name
-    s.id = stream.id
-    s.description = stream.description
-
-    if not stream.branches:
-        return
-
-    # branches = [branch for branch in stream.branches.items if branch.name != "globals"]
-    for b in stream.branches.items:
-        branch = s.branches.add()
-        branch.name = b.name
-
-        if not b.commits:
-            continue
-
-        for c in b.commits.items:
-            commit = branch.commits.add()
-            commit.id = commit.name = c.id
-            commit.message = c.message
-            commit.author_name = c.authorName
-            commit.author_id = c.authorId
-            commit.created_at = c.createdAt
-            commit.source_application = str(c.sourceApplication)
-
-    if hasattr(s, "baseProperties"):
-        s.units = stream.baseProperties.units
-    else:
-        s.units = "Meters"
-
-
-class LoadUserStreams(bpy.types.Operator):
-    """
-    Load all available streams for active user user
-    """
-
-    bl_idname = "speckle.load_user_streams"
-    bl_label = "Load user streams"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "(Re)load all available user streams"
-
-    def execute(self, context):
-        speckle = context.scene.speckle
-
-        if len(speckle.users) > 0:
-            user = speckle.users[int(context.scene.speckle.active_user)]
-            client = speckle_clients[int(context.scene.speckle.active_user)]
-
-            try:
-                streams = client.stream.list(stream_limit=20)
-            except Exception as e:
-                _report("Failed to retrieve streams: {}".format(e))
-                return
-            if not streams:
-                _report("Failed to retrieve streams.")
-                return
-
-            user.streams.clear()
-
-            default_units = "Meters"
-
-            for s in streams:
-                sstream = client.stream.get(id=s.id)
-                add_user_stream(user, sstream)
-
-            bpy.context.view_layer.update()
-
-            return {"FINISHED"}
-
-        if context.area:
-            context.area.tag_redraw()
-        return {"CANCELLED"}

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,19 +0,0 @@
-"""
-Addon properties
-"""
-
-import bpy
-from bpy.props import BoolProperty
-
-
-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,21 +0,0 @@
-"""
-Collection properties
-"""
-
-import bpy
-from bpy.props import StringProperty, BoolProperty, EnumProperty
-
-
-class SpeckleCollectionSettings(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."),
-        ),
-    )
-    stream_id: bpy.props.StringProperty(default="")
-    name: bpy.props.StringProperty(default="")
-    units: bpy.props.StringProperty(default="")

bpy_speckle/properties/object.py

@@ -1,20 +0,0 @@
-"""
-Object properties
-"""
-
-import bpy
-from bpy.props import StringProperty, BoolProperty, EnumProperty
-
-
-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."),
-        ),
-    )
-    stream_id: bpy.props.StringProperty(default="")
-    object_id: bpy.props.StringProperty(default="")

bpy_speckle/properties/scene.py

@@ -1,135 +0,0 @@
-"""
-Scene properties
-"""
-
-import bpy
-from bpy.props import (
-    StringProperty,
-    BoolProperty,
-    FloatProperty,
-    CollectionProperty,
-    EnumProperty,
-    IntProperty,
-    PointerProperty,
-)
-from specklepy.api.client import SpeckleClient
-
-
-class SpeckleSceneObject(bpy.types.PropertyGroup):
-    name: bpy.props.StringProperty(default="")
-
-
-class SpeckleCommitObject(bpy.types.PropertyGroup):
-    id: StringProperty(default="abc")
-    message: StringProperty(default="A simple commit")
-    author_name: StringProperty(default="Author name")
-    author_id: StringProperty(default="Author ID")
-    created_at: StringProperty(default="Today")
-    source_application: StringProperty(default="Unknown")
-
-
-class SpeckleBranchObject(bpy.types.PropertyGroup):
-    def get_commits(self, context):
-        if self.commits != None and len(self.commits) > 0:
-            return [
-                (str(i), commit.id, commit.message, i)
-                for i, commit in enumerate(self.commits)
-            ]
-        return [("0", "<none>", "<none>", 0)]
-
-    name: StringProperty(default="main")
-    commits: CollectionProperty(type=SpeckleCommitObject)
-    commit: EnumProperty(
-        name="Commit",
-        description="Active commit",
-        items=get_commits,
-    )
-
-
-class SpeckleStreamObject(bpy.types.PropertyGroup):
-    def get_branches(self, context):
-        if self.branches:
-            return [
-                (str(i), branch.name, branch.name, i)
-                for i, branch in enumerate(self.branches)
-                if branch.name != "globals"
-            ]
-        return [("0", "<none>", "<none>", 0)]
-
-    name: StringProperty(default="SpeckleStream")
-    description: StringProperty(default="No description provided.")
-    id: StringProperty(default="")
-    units: StringProperty(default="Meters")
-    query: StringProperty(default="")
-    branches: CollectionProperty(type=SpeckleBranchObject)
-    branch: EnumProperty(
-        name="Branch",
-        description="Active branch",
-        items=get_branches,
-    )
-
-
-class SpeckleUserObject(bpy.types.PropertyGroup):
-    server_name: StringProperty(default="SpeckleXYZ")
-    server_url: StringProperty(default="https://speckle.xyz")
-    name: StringProperty(default="Speckle User")
-    email: StringProperty(default="user@speckle.xyz")
-    company: StringProperty(default="SpeckleSystems")
-    authToken: StringProperty(default="")
-    streams: CollectionProperty(type=SpeckleStreamObject)
-    active_stream: IntProperty(default=0)
-
-
-class SpeckleSceneSettings(bpy.types.PropertyGroup):
-    def get_scripts(self, context):
-        seq = [("<none>", "<none>", "<none>")]
-        seq.extend([(t.name, t.name, t.name) for t in bpy.data.texts])
-        return seq
-
-    streams: EnumProperty(
-        name="Available streams",
-        description="Available streams associated with user.",
-        items=[],
-    )
-
-    users: CollectionProperty(type=SpeckleUserObject)
-
-    def get_users(self, context):
-        return [
-            (str(i), "{} ({})".format(user.email, user.server_name), user.server_url, i)
-            for i, user in enumerate(self.users)
-        ]
-
-    def set_user(self, context):
-        bpy.ops.speckle.load_user_streams()
-
-    active_user: EnumProperty(
-        items=get_users,
-        name="User",
-        description="Select user",
-        update=set_user,
-        get=None,
-        set=None,
-    )
-
-    objects: CollectionProperty(type=SpeckleSceneObject)
-
-    scale: FloatProperty(default=0.001)
-
-    user: StringProperty(
-        name="User",
-        description="Current user.",
-        default="Speckle User",
-    )
-
-    receive_script: EnumProperty(
-        name="Receive script",
-        description="Script to run when receiving stream objects.",
-        items=get_scripts,
-    )
-
-    send_script: EnumProperty(
-        name="Send script",
-        description="Script to run when sending stream objects.",
-        items=get_scripts,
-    )

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,35 +0,0 @@
-"""
-Object UI elements
-"""
-
-import bpy
-from bpy.props import (
-    StringProperty,
-    BoolProperty,
-    FloatProperty,
-    CollectionProperty,
-    EnumProperty,
-)
-
-
-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="Stream 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,277 +0,0 @@
-"""
-Speckle UI elements for the 3d viewport
-"""
-
-
-import bpy
-from bpy.props import (
-    StringProperty,
-    BoolProperty,
-    FloatProperty,
-    CollectionProperty,
-    EnumProperty,
-)
-
-import datetime
-
-"""
-Compatibility 
-TODO: evaluate if we should still support Blender <2.80
-"""
-
-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 stream list
-    """
-
-    def draw_item(self, context, layout, data, stream, active_data, active_propname):
-        if self.layout_type in {"DEFAULT", "COMPACT"}:
-            if stream:
-                # layout.prop(user, "name", text=user.name, emboss=False, icon_value=0)
-                layout.label(
-                    text="{} ({})".format(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="Streams", 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"
-
-    def draw(self, context):
-        speckle = context.scene.speckle
-
-        layout = self.layout
-        col = layout.column()
-
-        if len(speckle.users) < 1:
-            col.label(text="No users found.")
-        else:
-            # col.label(text="User")
-            col.prop(speckle, "active_user", text="")
-            user = speckle.users[int(speckle.active_user)]
-            col.label(text="{} ({})".format(user.server_name, user.server_url))
-            col.label(text="{} ({})".format(user.name, user.email))
-
-
-class VIEW3D_PT_SpeckleStreams(bpy.types.Panel):
-    """
-    Speckle Streams UI panel in the 3d viewport
-    """
-
-    bl_space_type = "VIEW_3D"
-    bl_region_type = Region
-    bl_category = "Speckle"
-    bl_context = "objectmode"
-    bl_label = "Streams"
-
-    def draw(self, context):
-        speckle = context.scene.speckle
-        col = self.layout.column()
-
-        if len(speckle.users) < 1:
-            col.label(text="No stream data.")
-        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.delete_stream", text="", icon="REMOVE")
-            row.operator("speckle.load_user_streams", text="", icon="FILE_REFRESH")
-
-
-class VIEW3D_PT_SpeckleActiveStream(bpy.types.Panel):
-    """
-    Speckle Active Streams UI panel in the 3d viewport
-    """
-
-    bl_space_type = "VIEW_3D"
-    bl_region_type = Region
-    bl_category = "Speckle"
-    bl_context = "objectmode"
-    bl_label = "Active stream"
-
-    def draw(self, context):
-        speckle = context.scene.speckle
-        col = self.layout.column()
-
-        if len(speckle.users) < 1:
-            col.label(text="No stream data.")
-        else:
-            user = speckle.users[int(speckle.active_user)]
-            if len(user.streams) < 1:
-                col.label(text="No active stream.")
-            else:
-                stream = user.streams[user.active_stream]
-                # user.active_stream = min(user.active_stream, len(user.streams) - 1)
-                row = col.row()
-                row.label(text="{} ({})".format(stream.name, stream.id))
-                row.operator("speckle.stream_copy_id", text="", icon="COPY_ID")
-                col.separator()
-
-                row = col.row()
-                row.prop(stream, "branch", text="")
-                row.operator("speckle.branch_copy_name", text="", icon="COPY_ID")
-
-                if len(stream.branches) > 0:
-                    branch = stream.branches[int(stream.branch)]
-
-                    row = col.row()
-                    row.prop(branch, "commit", text="")
-                    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.datetime.strptime(
-                            commit.created_at, "%Y-%m-%dT%H:%M:%S.%fZ"
-                        )
-                        col.label(text="{}".format(dt.ctime()))
-                        col.label(
-                            text="{} ({})".format(commit.author_name, commit.author_id)
-                        )
-                        col.label(text=commit.source_application)
-                else:
-                    col.label(text="No branches 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="")
-                area.prop(stream, "query", text="Filter")
-
-                col.separator()
-
-                row = col.row(align=True)
-                subcol = row.column()
-                subcol.label(text="Units:")
-                subcol = row.column()
-                subcol.label(text=stream.units)
-
-                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 Stream 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

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

patch_version.py

@@ -1,65 +1,47 @@
 import re
 import sys
 
+def patch_addon(simple_version: str):
+    """Patches the __init__.py bl_info version within the connector init file"""
+    FILE_PATH = "bpy_speckle/__init__.py"
+    version = simple_version.split(".")
 
-def patch_connector(tag):
-    """Patches the connector version within the connector init file"""
-    bpy_file = "bpy_speckle/__init__.py"
-    tag = tag.split(".")
-
-    with open(bpy_file, "r") as file:
+    with open(FILE_PATH, "r") as file:
         lines = file.readlines()
 
         for (index, line) in enumerate(lines):
             if '"version":' in line:
-                lines[index] = f'    "version": ({tag[0]}, {tag[1]}, {tag[2]}),\n'
-                print(f"Patched connector version number in {bpy_file}")
+                lines[index] = f'    "version": ({version[0]}, {version[1]}, {version[2]}),\n'
+
+        with open(FILE_PATH, "w") as file:
+            file.writelines(lines)
+
+def patch_manifest(simple_version: str):
+    """Patches the connector version within the connector init file"""
+    FILE_PATH = "bpy_speckle/blender_manifest.toml"
+    version = simple_version.split(".")
+
+    with open(FILE_PATH, "r") as file:
+        lines = file.readlines()
+
+        for (index, line) in enumerate(lines):
+            if line.startswith('version ='):
+                lines[index] = f'version = "{version[0]}.{version[1]}.{version[2]}",\n'
+                print(f"Patched connector version number in {FILE_PATH}")
                 break
 
-        with open(bpy_file, "w") as file:
+        with open(FILE_PATH, "w") as file:
             file.writelines(lines)
 
-
-def patch_installer(tag):
-    """Patches the installer with the correct connector version and specklepy version"""
-    iss_file = "speckle-sharp-ci-tools/blender.iss"
-
-    py_tag = get_specklepy_version()
-    with open(iss_file, "r") as file:
-        lines = file.readlines()
-        lines.insert(11, f'#define SpecklepyVersion "{py_tag}"\n')
-        lines.insert(11, f'#define AppVersion "{tag}"\n')
-
-        with open(iss_file, "w") as file:
-            file.writelines(lines)
-            print(f"Patched installer with connector v{tag} and specklepy v{py_tag}")
-
-
-def get_specklepy_version():
-    """Get version of specklepy to install from the pyproject.toml"""
-    version = "2.3.3"
-    with open("pyproject.toml", "r") as f:
-        lines = [line for line in f if line.startswith("specklepy = ")]
-        if not lines:
-            raise Exception("Could not find specklepy in pyproject.toml")
-        match = re.search(r"[0-9]+(\.[0-9]+)*", lines[0])
-        if match:
-            version = match[0]
-    return version
-
-
 def main():
-    if len(sys.argv) < 2:
-        print(get_specklepy_version())
-        return
-
     tag = sys.argv[1]
-    if not re.match(r"[0-9]+(\.[0-9]+)*$", tag):
+    if not re.match(r"([0-9]+)\.([0-9]+)\.([0-9]+)", tag):
         raise ValueError(f"Invalid tag provided: {tag}")
 
     print(f"Patching version: {tag}")
-    patch_connector(tag)
-    patch_installer(tag)
+    simple_version = tag.split("-")[0]
+    patch_addon(simple_version)
+    patch_manifest(simple_version)
 
 
 if __name__ == "__main__":

poetry.lock

@@ -1,824 +0,0 @@
-[[package]]
-name = "aiohttp"
-version = "3.7.4.post0"
-description = "Async http client/server framework (asyncio)"
-category = "main"
-optional = false
-python-versions = ">=3.6"
-
-[package.dependencies]
-async-timeout = ">=3.0,<4.0"
-attrs = ">=17.3.0"
-chardet = ">=2.0,<5.0"
-multidict = ">=4.5,<7.0"
-typing-extensions = ">=3.6.5"
-yarl = ">=1.0,<2.0"
-
-[package.extras]
-speedups = ["aiodns", "brotlipy", "cchardet"]
-
-[[package]]
-name = "appdirs"
-version = "1.4.4"
-description = "A small Python module for determining appropriate platform-specific dirs, e.g. a \"user data dir\"."
-category = "main"
-optional = false
-python-versions = "*"
-
-[[package]]
-name = "async-timeout"
-version = "3.0.1"
-description = "Timeout context manager for asyncio programs"
-category = "main"
-optional = false
-python-versions = ">=3.5.3"
-
-[[package]]
-name = "attrs"
-version = "21.2.0"
-description = "Classes Without Boilerplate"
-category = "main"
-optional = false
-python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"
-
-[package.extras]
-dev = ["coverage[toml] (>=5.0.2)", "hypothesis", "pympler", "pytest (>=4.3.0)", "six", "mypy", "pytest-mypy-plugins", "zope.interface", "furo", "sphinx", "sphinx-notfound-page", "pre-commit"]
-docs = ["furo", "sphinx", "zope.interface", "sphinx-notfound-page"]
-tests = ["coverage[toml] (>=5.0.2)", "hypothesis", "pympler", "pytest (>=4.3.0)", "six", "mypy", "pytest-mypy-plugins", "zope.interface"]
-tests_no_zope = ["coverage[toml] (>=5.0.2)", "hypothesis", "pympler", "pytest (>=4.3.0)", "six", "mypy", "pytest-mypy-plugins"]
-
-[[package]]
-name = "bpy"
-version = "2.82.1"
-description = "Blender as a python module"
-category = "dev"
-optional = false
-python-versions = ">=3.7, <3.8"
-
-[[package]]
-name = "bpy-build"
-version = "2.1.0"
-description = "Find Blender sources in version control, create build scripts"
-category = "dev"
-optional = false
-python-versions = ">=3.4.0"
-
-[package.dependencies]
-cmake = ">=3.13.5"
-cmake-generators = "*"
-distro = "*"
-GitPython = "*"
-svn = "*"
-
-[[package]]
-name = "certifi"
-version = "2021.10.8"
-description = "Python package for providing Mozilla's CA Bundle."
-category = "main"
-optional = false
-python-versions = "*"
-
-[[package]]
-name = "chardet"
-version = "4.0.0"
-description = "Universal encoding detector for Python 2 and 3"
-category = "main"
-optional = false
-python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"
-
-[[package]]
-name = "charset-normalizer"
-version = "2.0.8"
-description = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet."
-category = "main"
-optional = false
-python-versions = ">=3.5.0"
-
-[package.extras]
-unicode_backport = ["unicodedata2"]
-
-[[package]]
-name = "cmake"
-version = "3.22.0"
-description = "CMake is an open-source, cross-platform family of tools designed to build, test and package software"
-category = "dev"
-optional = false
-python-versions = "*"
-
-[package.extras]
-test = ["codecov (>=2.0.5)", "coverage (>=4.2)", "flake8 (>=3.0.4)", "path.py (>=11.5.0)", "pytest (>=3.0.3)", "pytest-cov (>=2.4.0)", "pytest-runner (>=2.9)", "pytest-virtualenv (>=1.7.0)", "scikit-build (>=0.10.0)", "setuptools (>=28.0.0)", "virtualenv (>=15.0.3)", "wheel"]
-
-[[package]]
-name = "cmake-generators"
-version = "1.0.9"
-description = "Query cmake-generators"
-category = "dev"
-optional = false
-python-versions = ">=3.4.0"
-
-[[package]]
-name = "devtools"
-version = "0.6.1"
-description = "Python's missing debug print command and other development tools."
-category = "dev"
-optional = false
-python-versions = ">=3.6"
-
-[package.extras]
-pygments = ["Pygments (>=2.2.0)"]
-
-[[package]]
-name = "distro"
-version = "1.6.0"
-description = "Distro - an OS platform information API"
-category = "dev"
-optional = false
-python-versions = "*"
-
-[[package]]
-name = "gitdb"
-version = "4.0.9"
-description = "Git Object Database"
-category = "dev"
-optional = false
-python-versions = ">=3.6"
-
-[package.dependencies]
-smmap = ">=3.0.1,<6"
-
-[[package]]
-name = "gitpython"
-version = "3.1.24"
-description = "GitPython is a python library used to interact with Git repositories"
-category = "dev"
-optional = false
-python-versions = ">=3.7"
-
-[package.dependencies]
-gitdb = ">=4.0.1,<5"
-typing-extensions = {version = ">=3.7.4.3", markers = "python_version < \"3.10\""}
-
-[[package]]
-name = "gql"
-version = "3.0.0b1"
-description = "GraphQL client for Python"
-category = "main"
-optional = false
-python-versions = "*"
-
-[package.dependencies]
-aiohttp = {version = ">=3.7.1,<3.8.0", optional = true, markers = "extra == \"all\""}
-graphql-core = ">=3.1.5,<3.2"
-requests = {version = ">=2.26,<3", optional = true, markers = "extra == \"all\""}
-requests_toolbelt = {version = ">=0.9.1,<1", optional = true, markers = "extra == \"all\""}
-urllib3 = {version = ">=1.26", optional = true, markers = "extra == \"all\""}
-websockets = {version = ">=9,<10", optional = true, markers = "extra == \"all\""}
-yarl = ">=1.6,<2.0"
-
-[package.extras]
-aiohttp = ["aiohttp (>=3.7.1,<3.8.0)"]
-all = ["aiohttp (>=3.7.1,<3.8.0)", "requests (>=2.26,<3)", "requests_toolbelt (>=0.9.1,<1)", "urllib3 (>=1.26)", "websockets (>=9,<10)"]
-dev = ["aiohttp (>=3.7.1,<3.8.0)", "requests (>=2.26,<3)", "requests_toolbelt (>=0.9.1,<1)", "urllib3 (>=1.26)", "websockets (>=9,<10)", "black (==19.10b0)", "check-manifest (>=0.42,<1)", "flake8 (==3.8.1)", "isort (==4.3.21)", "mypy (==0.770)", "sphinx (>=3.0.0,<4)", "sphinx_rtd_theme (>=0.4,<1)", "sphinx-argparse (==0.2.5)", "parse (==1.15.0)", "pytest (==5.4.2)", "pytest-asyncio (==0.11.0)", "pytest-cov (==2.8.1)", "mock (==4.0.2)", "vcrpy (==4.0.2)", "aiofiles"]
-requests = ["requests (>=2.26,<3)", "requests_toolbelt (>=0.9.1,<1)", "urllib3 (>=1.26)"]
-test = ["aiohttp (>=3.7.1,<3.8.0)", "requests (>=2.26,<3)", "requests_toolbelt (>=0.9.1,<1)", "urllib3 (>=1.26)", "websockets (>=9,<10)", "parse (==1.15.0)", "pytest (==5.4.2)", "pytest-asyncio (==0.11.0)", "pytest-cov (==2.8.1)", "mock (==4.0.2)", "vcrpy (==4.0.2)", "aiofiles"]
-test_no_transport = ["parse (==1.15.0)", "pytest (==5.4.2)", "pytest-asyncio (==0.11.0)", "pytest-cov (==2.8.1)", "mock (==4.0.2)", "vcrpy (==4.0.2)", "aiofiles"]
-websockets = ["websockets (>=9,<10)"]
-
-[[package]]
-name = "graphql-core"
-version = "3.1.6"
-description = "GraphQL implementation for Python, a port of GraphQL.js, the JavaScript reference implementation for GraphQL."
-category = "main"
-optional = false
-python-versions = ">=3.6,<4"
-
-[[package]]
-name = "idna"
-version = "3.3"
-description = "Internationalized Domain Names in Applications (IDNA)"
-category = "main"
-optional = false
-python-versions = ">=3.5"
-
-[[package]]
-name = "multidict"
-version = "5.2.0"
-description = "multidict implementation"
-category = "main"
-optional = false
-python-versions = ">=3.6"
-
-[[package]]
-name = "nose"
-version = "1.3.7"
-description = "nose extends unittest to make testing easier"
-category = "dev"
-optional = false
-python-versions = "*"
-
-[[package]]
-name = "numpy"
-version = "1.21.4"
-description = "NumPy is the fundamental package for array computing with Python."
-category = "dev"
-optional = false
-python-versions = ">=3.7,<3.11"
-
-[[package]]
-name = "pydantic"
-version = "1.8.2"
-description = "Data validation and settings management using python 3.6 type hinting"
-category = "main"
-optional = false
-python-versions = ">=3.6.1"
-
-[package.dependencies]
-typing-extensions = ">=3.7.4.3"
-
-[package.extras]
-dotenv = ["python-dotenv (>=0.10.4)"]
-email = ["email-validator (>=1.0.3)"]
-
-[[package]]
-name = "python-dateutil"
-version = "2.8.2"
-description = "Extensions to the standard Python datetime module"
-category = "dev"
-optional = false
-python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,>=2.7"
-
-[package.dependencies]
-six = ">=1.5"
-
-[[package]]
-name = "requests"
-version = "2.26.0"
-description = "Python HTTP for Humans."
-category = "main"
-optional = false
-python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*"
-
-[package.dependencies]
-certifi = ">=2017.4.17"
-charset-normalizer = {version = ">=2.0.0,<2.1.0", markers = "python_version >= \"3\""}
-idna = {version = ">=2.5,<4", markers = "python_version >= \"3\""}
-urllib3 = ">=1.21.1,<1.27"
-
-[package.extras]
-socks = ["PySocks (>=1.5.6,!=1.5.7)", "win-inet-pton"]
-use_chardet_on_py3 = ["chardet (>=3.0.2,<5)"]
-
-[[package]]
-name = "requests-toolbelt"
-version = "0.9.1"
-description = "A utility belt for advanced users of python-requests"
-category = "main"
-optional = false
-python-versions = "*"
-
-[package.dependencies]
-requests = ">=2.0.1,<3.0.0"
-
-[[package]]
-name = "six"
-version = "1.16.0"
-description = "Python 2 and 3 compatibility utilities"
-category = "dev"
-optional = false
-python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*"
-
-[[package]]
-name = "smmap"
-version = "5.0.0"
-description = "A pure Python implementation of a sliding window memory map manager"
-category = "dev"
-optional = false
-python-versions = ">=3.6"
-
-[[package]]
-name = "specklepy"
-version = "2.4.2"
-description = "The Python SDK for Speckle 2.0"
-category = "main"
-optional = false
-python-versions = ">=3.6.5,<4.0.0"
-
-[package.dependencies]
-appdirs = ">=1.4.4,<2.0.0"
-gql = {version = ">=3.0.0b1", extras = ["all"]}
-pydantic = ">=1.8.2,<2.0.0"
-ujson = ">=4.3.0,<5.0.0"
-
-[[package]]
-name = "svn"
-version = "1.0.1"
-description = "Intuitive Subversion wrapper."
-category = "dev"
-optional = false
-python-versions = "*"
-
-[package.dependencies]
-nose = "*"
-python-dateutil = ">=2.2"
-
-[[package]]
-name = "typing-extensions"
-version = "4.0.0"
-description = "Backported and Experimental Type Hints for Python 3.6+"
-category = "main"
-optional = false
-python-versions = ">=3.6"
-
-[[package]]
-name = "ujson"
-version = "4.3.0"
-description = "Ultra fast JSON encoder and decoder for Python"
-category = "main"
-optional = false
-python-versions = ">=3.6"
-
-[[package]]
-name = "urllib3"
-version = "1.26.7"
-description = "HTTP library with thread-safe connection pooling, file post, and more."
-category = "main"
-optional = false
-python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, <4"
-
-[package.extras]
-brotli = ["brotlipy (>=0.6.0)"]
-secure = ["pyOpenSSL (>=0.14)", "cryptography (>=1.3.4)", "idna (>=2.0.0)", "certifi", "ipaddress"]
-socks = ["PySocks (>=1.5.6,!=1.5.7,<2.0)"]
-
-[[package]]
-name = "websockets"
-version = "9.1"
-description = "An implementation of the WebSocket Protocol (RFC 6455 & 7692)"
-category = "main"
-optional = false
-python-versions = ">=3.6.1"
-
-[[package]]
-name = "yarl"
-version = "1.7.2"
-description = "Yet another URL library"
-category = "main"
-optional = false
-python-versions = ">=3.6"
-
-[package.dependencies]
-idna = ">=2.0"
-multidict = ">=4.0"
-typing-extensions = {version = ">=3.7.4", markers = "python_version < \"3.8\""}
-
-[metadata]
-lock-version = "1.1"
-python-versions = ">=3.7,<3.8"
-content-hash = "1459bac4b94b1801e6c6a0daebc87550e8cd6605ecfeb877aa0be1055c1d9380"
-
-[metadata.files]
-aiohttp = [
-    {file = "aiohttp-3.7.4.post0-cp36-cp36m-macosx_10_14_x86_64.whl", hash = "sha256:3cf75f7cdc2397ed4442594b935a11ed5569961333d49b7539ea741be2cc79d5"},
-    {file = "aiohttp-3.7.4.post0-cp36-cp36m-manylinux1_i686.whl", hash = "sha256:4b302b45040890cea949ad092479e01ba25911a15e648429c7c5aae9650c67a8"},
-    {file = "aiohttp-3.7.4.post0-cp36-cp36m-manylinux2014_aarch64.whl", hash = "sha256:fe60131d21b31fd1a14bd43e6bb88256f69dfc3188b3a89d736d6c71ed43ec95"},
-    {file = "aiohttp-3.7.4.post0-cp36-cp36m-manylinux2014_i686.whl", hash = "sha256:393f389841e8f2dfc86f774ad22f00923fdee66d238af89b70ea314c4aefd290"},
-    {file = "aiohttp-3.7.4.post0-cp36-cp36m-manylinux2014_ppc64le.whl", hash = "sha256:c6e9dcb4cb338d91a73f178d866d051efe7c62a7166653a91e7d9fb18274058f"},
-    {file = "aiohttp-3.7.4.post0-cp36-cp36m-manylinux2014_s390x.whl", hash = "sha256:5df68496d19f849921f05f14f31bd6ef53ad4b00245da3195048c69934521809"},
-    {file = "aiohttp-3.7.4.post0-cp36-cp36m-manylinux2014_x86_64.whl", hash = "sha256:0563c1b3826945eecd62186f3f5c7d31abb7391fedc893b7e2b26303b5a9f3fe"},
-    {file = "aiohttp-3.7.4.post0-cp36-cp36m-win32.whl", hash = "sha256:3d78619672183be860b96ed96f533046ec97ca067fd46ac1f6a09cd9b7484287"},
-    {file = "aiohttp-3.7.4.post0-cp36-cp36m-win_amd64.whl", hash = "sha256:f705e12750171c0ab4ef2a3c76b9a4024a62c4103e3a55dd6f99265b9bc6fcfc"},
-    {file = "aiohttp-3.7.4.post0-cp37-cp37m-macosx_10_14_x86_64.whl", hash = "sha256:230a8f7e24298dea47659251abc0fd8b3c4e38a664c59d4b89cca7f6c09c9e87"},
-    {file = "aiohttp-3.7.4.post0-cp37-cp37m-manylinux1_i686.whl", hash = "sha256:2e19413bf84934d651344783c9f5e22dee452e251cfd220ebadbed2d9931dbf0"},
-    {file = "aiohttp-3.7.4.post0-cp37-cp37m-manylinux2014_aarch64.whl", hash = "sha256:e4b2b334e68b18ac9817d828ba44d8fcb391f6acb398bcc5062b14b2cbeac970"},
-    {file = "aiohttp-3.7.4.post0-cp37-cp37m-manylinux2014_i686.whl", hash = "sha256:d012ad7911653a906425d8473a1465caa9f8dea7fcf07b6d870397b774ea7c0f"},
-    {file = "aiohttp-3.7.4.post0-cp37-cp37m-manylinux2014_ppc64le.whl", hash = "sha256:40eced07f07a9e60e825554a31f923e8d3997cfc7fb31dbc1328c70826e04cde"},
-    {file = "aiohttp-3.7.4.post0-cp37-cp37m-manylinux2014_s390x.whl", hash = "sha256:209b4a8ee987eccc91e2bd3ac36adee0e53a5970b8ac52c273f7f8fd4872c94c"},
-    {file = "aiohttp-3.7.4.post0-cp37-cp37m-manylinux2014_x86_64.whl", hash = "sha256:14762875b22d0055f05d12abc7f7d61d5fd4fe4642ce1a249abdf8c700bf1fd8"},
-    {file = "aiohttp-3.7.4.post0-cp37-cp37m-win32.whl", hash = "sha256:7615dab56bb07bff74bc865307aeb89a8bfd9941d2ef9d817b9436da3a0ea54f"},
-    {file = "aiohttp-3.7.4.post0-cp37-cp37m-win_amd64.whl", hash = "sha256:d9e13b33afd39ddeb377eff2c1c4f00544e191e1d1dee5b6c51ddee8ea6f0cf5"},
-    {file = "aiohttp-3.7.4.post0-cp38-cp38-macosx_10_14_x86_64.whl", hash = "sha256:547da6cacac20666422d4882cfcd51298d45f7ccb60a04ec27424d2f36ba3eaf"},
-    {file = "aiohttp-3.7.4.post0-cp38-cp38-manylinux1_i686.whl", hash = "sha256:af9aa9ef5ba1fd5b8c948bb11f44891968ab30356d65fd0cc6707d989cd521df"},
-    {file = "aiohttp-3.7.4.post0-cp38-cp38-manylinux2014_aarch64.whl", hash = "sha256:64322071e046020e8797117b3658b9c2f80e3267daec409b350b6a7a05041213"},
-    {file = "aiohttp-3.7.4.post0-cp38-cp38-manylinux2014_i686.whl", hash = "sha256:bb437315738aa441251214dad17428cafda9cdc9729499f1d6001748e1d432f4"},
-    {file = "aiohttp-3.7.4.post0-cp38-cp38-manylinux2014_ppc64le.whl", hash = "sha256:e54962802d4b8b18b6207d4a927032826af39395a3bd9196a5af43fc4e60b009"},
-    {file = "aiohttp-3.7.4.post0-cp38-cp38-manylinux2014_s390x.whl", hash = "sha256:a00bb73540af068ca7390e636c01cbc4f644961896fa9363154ff43fd37af2f5"},
-    {file = "aiohttp-3.7.4.post0-cp38-cp38-manylinux2014_x86_64.whl", hash = "sha256:79ebfc238612123a713a457d92afb4096e2148be17df6c50fb9bf7a81c2f8013"},
-    {file = "aiohttp-3.7.4.post0-cp38-cp38-win32.whl", hash = "sha256:515dfef7f869a0feb2afee66b957cc7bbe9ad0cdee45aec7fdc623f4ecd4fb16"},
-    {file = "aiohttp-3.7.4.post0-cp38-cp38-win_amd64.whl", hash = "sha256:114b281e4d68302a324dd33abb04778e8557d88947875cbf4e842c2c01a030c5"},
-    {file = "aiohttp-3.7.4.post0-cp39-cp39-macosx_10_14_x86_64.whl", hash = "sha256:7b18b97cf8ee5452fa5f4e3af95d01d84d86d32c5e2bfa260cf041749d66360b"},
-    {file = "aiohttp-3.7.4.post0-cp39-cp39-manylinux1_i686.whl", hash = "sha256:15492a6368d985b76a2a5fdd2166cddfea5d24e69eefed4630cbaae5c81d89bd"},
-    {file = "aiohttp-3.7.4.post0-cp39-cp39-manylinux2014_aarch64.whl", hash = "sha256:bdb230b4943891321e06fc7def63c7aace16095be7d9cf3b1e01be2f10fba439"},
-    {file = "aiohttp-3.7.4.post0-cp39-cp39-manylinux2014_i686.whl", hash = "sha256:cffe3ab27871bc3ea47df5d8f7013945712c46a3cc5a95b6bee15887f1675c22"},
-    {file = "aiohttp-3.7.4.post0-cp39-cp39-manylinux2014_ppc64le.whl", hash = "sha256:f881853d2643a29e643609da57b96d5f9c9b93f62429dcc1cbb413c7d07f0e1a"},
-    {file = "aiohttp-3.7.4.post0-cp39-cp39-manylinux2014_s390x.whl", hash = "sha256:a5ca29ee66f8343ed336816c553e82d6cade48a3ad702b9ffa6125d187e2dedb"},
-    {file = "aiohttp-3.7.4.post0-cp39-cp39-manylinux2014_x86_64.whl", hash = "sha256:17c073de315745a1510393a96e680d20af8e67e324f70b42accbd4cb3315c9fb"},
-    {file = "aiohttp-3.7.4.post0-cp39-cp39-win32.whl", hash = "sha256:932bb1ea39a54e9ea27fc9232163059a0b8855256f4052e776357ad9add6f1c9"},
-    {file = "aiohttp-3.7.4.post0-cp39-cp39-win_amd64.whl", hash = "sha256:02f46fc0e3c5ac58b80d4d56eb0a7c7d97fcef69ace9326289fb9f1955e65cfe"},
-    {file = "aiohttp-3.7.4.post0.tar.gz", hash = "sha256:493d3299ebe5f5a7c66b9819eacdcfbbaaf1a8e84911ddffcdc48888497afecf"},
-]
-appdirs = [
-    {file = "appdirs-1.4.4-py2.py3-none-any.whl", hash = "sha256:a841dacd6b99318a741b166adb07e19ee71a274450e68237b4650ca1055ab128"},
-    {file = "appdirs-1.4.4.tar.gz", hash = "sha256:7d5d0167b2b1ba821647616af46a749d1c653740dd0d2415100fe26e27afdf41"},
-]
-async-timeout = [
-    {file = "async-timeout-3.0.1.tar.gz", hash = "sha256:0c3c816a028d47f659d6ff5c745cb2acf1f966da1fe5c19c77a70282b25f4c5f"},
-    {file = "async_timeout-3.0.1-py3-none-any.whl", hash = "sha256:4291ca197d287d274d0b6cb5d6f8f8f82d434ed288f962539ff18cc9012f9ea3"},
-]
-attrs = [
-    {file = "attrs-21.2.0-py2.py3-none-any.whl", hash = "sha256:149e90d6d8ac20db7a955ad60cf0e6881a3f20d37096140088356da6c716b0b1"},
-    {file = "attrs-21.2.0.tar.gz", hash = "sha256:ef6aaac3ca6cd92904cdd0d83f629a15f18053ec84e6432106f7a4d04ae4f5fb"},
-]
-bpy = [
-    {file = "bpy-2.82.1-cp37-cp37m-win_amd64.whl", hash = "sha256:ccbd1b7a62ffe67978723e91ff4df733c1a6b7c35a83bc0364b012ce4390167a"},
-    {file = "bpy-2.82.1.tar.gz", hash = "sha256:5f84452552724ae32faca9d001741e982f9cd61640c39975c6a6b734b29f5c35"},
-]
-bpy-build = [
-    {file = "bpy-build-2.1.0.tar.gz", hash = "sha256:8b6c621ec51718bdc3c973e47060bfd8df175416d32c1700b677e994e1b8e53c"},
-    {file = "bpy_build-2.1.0-py3-none-any.whl", hash = "sha256:29a72b4b83e7612db8e8208f19854250aad0c4310f883998d9eae01fe645dbc4"},
-]
-certifi = [
-    {file = "certifi-2021.10.8-py2.py3-none-any.whl", hash = "sha256:d62a0163eb4c2344ac042ab2bdf75399a71a2d8c7d47eac2e2ee91b9d6339569"},
-    {file = "certifi-2021.10.8.tar.gz", hash = "sha256:78884e7c1d4b00ce3cea67b44566851c4343c120abd683433ce934a68ea58872"},
-]
-chardet = [
-    {file = "chardet-4.0.0-py2.py3-none-any.whl", hash = "sha256:f864054d66fd9118f2e67044ac8981a54775ec5b67aed0441892edb553d21da5"},
-    {file = "chardet-4.0.0.tar.gz", hash = "sha256:0d6f53a15db4120f2b08c94f11e7d93d2c911ee118b6b30a04ec3ee8310179fa"},
-]
-charset-normalizer = [
-    {file = "charset-normalizer-2.0.8.tar.gz", hash = "sha256:735e240d9a8506778cd7a453d97e817e536bb1fc29f4f6961ce297b9c7a917b0"},
-    {file = "charset_normalizer-2.0.8-py3-none-any.whl", hash = "sha256:83fcdeb225499d6344c8f7f34684c2981270beacc32ede2e669e94f7fa544405"},
-]
-cmake = [
-    {file = "cmake-3.22.0-py2.py3-none-macosx_10_9_universal2.macosx_10_9_x86_64.macosx_11_0_arm64.macosx_11_0_universal2.whl", hash = "sha256:99b53d7c4aeea6ec6c61929c642b20265f56d3471a0c38858ea4894d1554683a"},
-    {file = "cmake-3.22.0-py2.py3-none-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:282dbb00f1c0aeb58243b490cb1e033ac159b9c13154c78afb08f18126472660"},
-    {file = "cmake-3.22.0-py2.py3-none-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:4f9f672a556921c92033dc084425990a8823d23ff468a24d154729f4418710ab"},
-    {file = "cmake-3.22.0-py2.py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e45e4499572fe3d76123c1d18d5065a5babad3ed5020465fdf88749205ee8dc2"},
-    {file = "cmake-3.22.0-py2.py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7d7f6b9a2d31e7a94b989cc672f242a0286a5f6a2bbc0057e6e9455794f7c127"},
-    {file = "cmake-3.22.0-py2.py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d9904ca81ac2a3dc4c27886c8411e90ca8b0f447f6b16a7caf545078a9979730"},
-    {file = "cmake-3.22.0-py2.py3-none-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:cda7e807c7c5a0a4f2df8e3f10a9871a292d0114a1f055b8c4c599911ab8f506"},
-    {file = "cmake-3.22.0-py2.py3-none-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:57e44238d36f4ffffe6e31b064687ce03fae6dc46ec4766b5d82638a2c0c8be4"},
-    {file = "cmake-3.22.0-py2.py3-none-musllinux_1_1_aarch64.whl", hash = "sha256:0aa6bb09eef0c927669d3c9f48d54f28968da7d2c916e693e626814b2e0b3865"},
-    {file = "cmake-3.22.0-py2.py3-none-musllinux_1_1_i686.whl", hash = "sha256:72a13c7d59cd4af9d62da3bd19b4b509e353b7fcebef9887f73d23bbfd82a7b5"},
-    {file = "cmake-3.22.0-py2.py3-none-musllinux_1_1_ppc64le.whl", hash = "sha256:fc62764c07d49607aefa79be05023f1a7698614d03e2f28b5116a977841423b1"},
-    {file = "cmake-3.22.0-py2.py3-none-musllinux_1_1_s390x.whl", hash = "sha256:78b2a8e23cbcd054d63be38b88c5920b48d68d0d620a7ad3389577e370e7a91a"},
-    {file = "cmake-3.22.0-py2.py3-none-musllinux_1_1_x86_64.whl", hash = "sha256:1b24893566cf60350a4601c28f3111c55b48e9da1104f591170748404e8d27b8"},
-    {file = "cmake-3.22.0-py2.py3-none-win32.whl", hash = "sha256:8affabaa556acbf3ef863d453b35193f208618e2f2e7955a9eeaf431bd9ebd4c"},
-    {file = "cmake-3.22.0-py2.py3-none-win_amd64.whl", hash = "sha256:c268288cb088c3de4afc73e10830f64494db2ea78c457f287cb8ccafdffd1eb9"},
-    {file = "cmake-3.22.0.tar.gz", hash = "sha256:5a3ccf93dea99791db93cd8babb52e4b70f92d2b380705ee35570cdd5b7a8e8b"},
-]
-cmake-generators = [
-    {file = "cmake-generators-1.0.9.tar.gz", hash = "sha256:2b03bdcd69345c03ffa56aa025b3163bd26b1465561c365a79cf1c6a31672ebf"},
-    {file = "cmake_generators-1.0.9-py3-none-any.whl", hash = "sha256:23428a5b7c6b1f54071dcf88f962fdf958f5c344d9df22330541378c83bf386b"},
-]
-devtools = [
-    {file = "devtools-0.6.1-py3-none-any.whl", hash = "sha256:7334183972a8d04e81d08b7f62126abca9b6f4de51d825c5fdcb9c88f252601a"},
-    {file = "devtools-0.6.1.tar.gz", hash = "sha256:a054307594d35d28fae8df7629967363e851ae0ac7b2152640a8a401c39d42d7"},
-]
-distro = [
-    {file = "distro-1.6.0-py2.py3-none-any.whl", hash = "sha256:c8713330ab31a034623a9515663ed87696700b55f04556b97c39cd261aa70dc7"},
-    {file = "distro-1.6.0.tar.gz", hash = "sha256:83f5e5a09f9c5f68f60173de572930effbcc0287bb84fdc4426cb4168c088424"},
-]
-gitdb = [
-    {file = "gitdb-4.0.9-py3-none-any.whl", hash = "sha256:8033ad4e853066ba6ca92050b9df2f89301b8fc8bf7e9324d412a63f8bf1a8fd"},
-    {file = "gitdb-4.0.9.tar.gz", hash = "sha256:bac2fd45c0a1c9cf619e63a90d62bdc63892ef92387424b855792a6cabe789aa"},
-]
-gitpython = [
-    {file = "GitPython-3.1.24-py3-none-any.whl", hash = "sha256:dc0a7f2f697657acc8d7f89033e8b1ea94dd90356b2983bca89dc8d2ab3cc647"},
-    {file = "GitPython-3.1.24.tar.gz", hash = "sha256:df83fdf5e684fef7c6ee2c02fc68a5ceb7e7e759d08b694088d0cacb4eba59e5"},
-]
-gql = [
-    {file = "gql-3.0.0b1.tar.gz", hash = "sha256:a08195e73ed08785e1aef71a540e514f80dbfa711b9effba31ba15fcb687f1fd"},
-]
-graphql-core = [
-    {file = "graphql-core-3.1.6.tar.gz", hash = "sha256:e65975b6a13878f9113a1fa5320760585b522d139944e005936b1b8358d0651a"},
-    {file = "graphql_core-3.1.6-py3-none-any.whl", hash = "sha256:c78d09596d347e1cffd266c5384abfedf43ed1eae08729773bebb3d527fe5a14"},
-]
-idna = [
-    {file = "idna-3.3-py3-none-any.whl", hash = "sha256:84d9dd047ffa80596e0f246e2eab0b391788b0503584e8945f2368256d2735ff"},
-    {file = "idna-3.3.tar.gz", hash = "sha256:9d643ff0a55b762d5cdb124b8eaa99c66322e2157b69160bc32796e824360e6d"},
-]
-multidict = [
-    {file = "multidict-5.2.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:3822c5894c72e3b35aae9909bef66ec83e44522faf767c0ad39e0e2de11d3b55"},
-    {file = "multidict-5.2.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:28e6d883acd8674887d7edc896b91751dc2d8e87fbdca8359591a13872799e4e"},
-    {file = "multidict-5.2.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:b61f85101ef08cbbc37846ac0e43f027f7844f3fade9b7f6dd087178caedeee7"},
-    {file = "multidict-5.2.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d9b668c065968c5979fe6b6fa6760bb6ab9aeb94b75b73c0a9c1acf6393ac3bf"},
-    {file = "multidict-5.2.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:517d75522b7b18a3385726b54a081afd425d4f41144a5399e5abd97ccafdf36b"},
-    {file = "multidict-5.2.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1b4ac3ba7a97b35a5ccf34f41b5a8642a01d1e55454b699e5e8e7a99b5a3acf5"},
-    {file = "multidict-5.2.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:df23c83398715b26ab09574217ca21e14694917a0c857e356fd39e1c64f8283f"},
-    {file = "multidict-5.2.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:e58a9b5cc96e014ddf93c2227cbdeca94b56a7eb77300205d6e4001805391747"},
-    {file = "multidict-5.2.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:f76440e480c3b2ca7f843ff8a48dc82446b86ed4930552d736c0bac507498a52"},
-    {file = "multidict-5.2.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:cfde464ca4af42a629648c0b0d79b8f295cf5b695412451716531d6916461628"},
-    {file = "multidict-5.2.0-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:0fed465af2e0eb6357ba95795d003ac0bdb546305cc2366b1fc8f0ad67cc3fda"},
-    {file = "multidict-5.2.0-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:b70913cbf2e14275013be98a06ef4b412329fe7b4f83d64eb70dce8269ed1e1a"},
-    {file = "multidict-5.2.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:a5635bcf1b75f0f6ef3c8a1ad07b500104a971e38d3683167b9454cb6465ac86"},
-    {file = "multidict-5.2.0-cp310-cp310-win32.whl", hash = "sha256:77f0fb7200cc7dedda7a60912f2059086e29ff67cefbc58d2506638c1a9132d7"},
-    {file = "multidict-5.2.0-cp310-cp310-win_amd64.whl", hash = "sha256:9416cf11bcd73c861267e88aea71e9fcc35302b3943e45e1dbb4317f91a4b34f"},
-    {file = "multidict-5.2.0-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:fd77c8f3cba815aa69cb97ee2b2ef385c7c12ada9c734b0f3b32e26bb88bbf1d"},
-    {file = "multidict-5.2.0-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:98ec9aea6223adf46999f22e2c0ab6cf33f5914be604a404f658386a8f1fba37"},
-    {file = "multidict-5.2.0-cp36-cp36m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e5283c0a00f48e8cafcecadebfa0ed1dac8b39e295c7248c44c665c16dc1138b"},
-    {file = "multidict-5.2.0-cp36-cp36m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5f79c19c6420962eb17c7e48878a03053b7ccd7b69f389d5831c0a4a7f1ac0a1"},
-    {file = "multidict-5.2.0-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:e4a67f1080123de76e4e97a18d10350df6a7182e243312426d508712e99988d4"},
-    {file = "multidict-5.2.0-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:94b117e27efd8e08b4046c57461d5a114d26b40824995a2eb58372b94f9fca02"},
-    {file = "multidict-5.2.0-cp36-cp36m-musllinux_1_1_aarch64.whl", hash = "sha256:2e77282fd1d677c313ffcaddfec236bf23f273c4fba7cdf198108f5940ae10f5"},
-    {file = "multidict-5.2.0-cp36-cp36m-musllinux_1_1_i686.whl", hash = "sha256:116347c63ba049c1ea56e157fa8aa6edaf5e92925c9b64f3da7769bdfa012858"},
-    {file = "multidict-5.2.0-cp36-cp36m-musllinux_1_1_ppc64le.whl", hash = "sha256:dc3a866cf6c13d59a01878cd806f219340f3e82eed514485e094321f24900677"},
-    {file = "multidict-5.2.0-cp36-cp36m-musllinux_1_1_s390x.whl", hash = "sha256:ac42181292099d91217a82e3fa3ce0e0ddf3a74fd891b7c2b347a7f5aa0edded"},
-    {file = "multidict-5.2.0-cp36-cp36m-musllinux_1_1_x86_64.whl", hash = "sha256:f0bb0973f42ffcb5e3537548e0767079420aefd94ba990b61cf7bb8d47f4916d"},
-    {file = "multidict-5.2.0-cp36-cp36m-win32.whl", hash = "sha256:ea21d4d5104b4f840b91d9dc8cbc832aba9612121eaba503e54eaab1ad140eb9"},
-    {file = "multidict-5.2.0-cp36-cp36m-win_amd64.whl", hash = "sha256:e6453f3cbeb78440747096f239d282cc57a2997a16b5197c9bc839099e1633d0"},
-    {file = "multidict-5.2.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:d3def943bfd5f1c47d51fd324df1e806d8da1f8e105cc7f1c76a1daf0f7e17b0"},
-    {file = "multidict-5.2.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:35591729668a303a02b06e8dba0eb8140c4a1bfd4c4b3209a436a02a5ac1de11"},
-    {file = "multidict-5.2.0-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ce8cacda0b679ebc25624d5de66c705bc53dcc7c6f02a7fb0f3ca5e227d80422"},
-    {file = "multidict-5.2.0-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:baf1856fab8212bf35230c019cde7c641887e3fc08cadd39d32a421a30151ea3"},
-    {file = "multidict-5.2.0-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:a43616aec0f0d53c411582c451f5d3e1123a68cc7b3475d6f7d97a626f8ff90d"},
-    {file = "multidict-5.2.0-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:25cbd39a9029b409167aa0a20d8a17f502d43f2efebfe9e3ac019fe6796c59ac"},
-    {file = "multidict-5.2.0-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:0a2cbcfbea6dc776782a444db819c8b78afe4db597211298dd8b2222f73e9cd0"},
-    {file = "multidict-5.2.0-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:3d2d7d1fff8e09d99354c04c3fd5b560fb04639fd45926b34e27cfdec678a704"},
-    {file = "multidict-5.2.0-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:a37e9a68349f6abe24130846e2f1d2e38f7ddab30b81b754e5a1fde32f782b23"},
-    {file = "multidict-5.2.0-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:637c1896497ff19e1ee27c1c2c2ddaa9f2d134bbb5e0c52254361ea20486418d"},
-    {file = "multidict-5.2.0-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:9815765f9dcda04921ba467957be543423e5ec6a1136135d84f2ae092c50d87b"},
-    {file = "multidict-5.2.0-cp37-cp37m-win32.whl", hash = "sha256:8b911d74acdc1fe2941e59b4f1a278a330e9c34c6c8ca1ee21264c51ec9b67ef"},
-    {file = "multidict-5.2.0-cp37-cp37m-win_amd64.whl", hash = "sha256:380b868f55f63d048a25931a1632818f90e4be71d2081c2338fcf656d299949a"},
-    {file = "multidict-5.2.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:e7d81ce5744757d2f05fc41896e3b2ae0458464b14b5a2c1e87a6a9d69aefaa8"},
-    {file = "multidict-5.2.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:2d1d55cdf706ddc62822d394d1df53573d32a7a07d4f099470d3cb9323b721b6"},
-    {file = "multidict-5.2.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:a4771d0d0ac9d9fe9e24e33bed482a13dfc1256d008d101485fe460359476065"},
-    {file = "multidict-5.2.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da7d57ea65744d249427793c042094c4016789eb2562576fb831870f9c878d9e"},
-    {file = "multidict-5.2.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:cdd68778f96216596218b4e8882944d24a634d984ee1a5a049b300377878fa7c"},
-    {file = "multidict-5.2.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ecc99bce8ee42dcad15848c7885197d26841cb24fa2ee6e89d23b8993c871c64"},
-    {file = "multidict-5.2.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:067150fad08e6f2dd91a650c7a49ba65085303fcc3decbd64a57dc13a2733031"},
-    {file = "multidict-5.2.0-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:78c106b2b506b4d895ddc801ff509f941119394b89c9115580014127414e6c2d"},
-    {file = "multidict-5.2.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:e6c4fa1ec16e01e292315ba76eb1d012c025b99d22896bd14a66628b245e3e01"},
-    {file = "multidict-5.2.0-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:b227345e4186809d31f22087d0265655114af7cda442ecaf72246275865bebe4"},
-    {file = "multidict-5.2.0-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:06560fbdcf22c9387100979e65b26fba0816c162b888cb65b845d3def7a54c9b"},
-    {file = "multidict-5.2.0-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:7878b61c867fb2df7a95e44b316f88d5a3742390c99dfba6c557a21b30180cac"},
-    {file = "multidict-5.2.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:246145bff76cc4b19310f0ad28bd0769b940c2a49fc601b86bfd150cbd72bb22"},
-    {file = "multidict-5.2.0-cp38-cp38-win32.whl", hash = "sha256:c30ac9f562106cd9e8071c23949a067b10211917fdcb75b4718cf5775356a940"},
-    {file = "multidict-5.2.0-cp38-cp38-win_amd64.whl", hash = "sha256:f19001e790013ed580abfde2a4465388950728861b52f0da73e8e8a9418533c0"},
-    {file = "multidict-5.2.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:c1ff762e2ee126e6f1258650ac641e2b8e1f3d927a925aafcfde943b77a36d24"},
-    {file = "multidict-5.2.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:bd6c9c50bf2ad3f0448edaa1a3b55b2e6866ef8feca5d8dbec10ec7c94371d21"},
-    {file = "multidict-5.2.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:fc66d4016f6e50ed36fb39cd287a3878ffcebfa90008535c62e0e90a7ab713ae"},
-    {file = "multidict-5.2.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a9acb76d5f3dd9421874923da2ed1e76041cb51b9337fd7f507edde1d86535d6"},
-    {file = "multidict-5.2.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dfc924a7e946dd3c6360e50e8f750d51e3ef5395c95dc054bc9eab0f70df4f9c"},
-    {file = "multidict-5.2.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:32fdba7333eb2351fee2596b756d730d62b5827d5e1ab2f84e6cbb287cc67fe0"},
-    {file = "multidict-5.2.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:b9aad49466b8d828b96b9e3630006234879c8d3e2b0a9d99219b3121bc5cdb17"},
-    {file = "multidict-5.2.0-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:93de39267c4c676c9ebb2057e98a8138bade0d806aad4d864322eee0803140a0"},
-    {file = "multidict-5.2.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:f9bef5cff994ca3026fcc90680e326d1a19df9841c5e3d224076407cc21471a1"},
-    {file = "multidict-5.2.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:5f841c4f14331fd1e36cbf3336ed7be2cb2a8f110ce40ea253e5573387db7621"},
-    {file = "multidict-5.2.0-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:38ba256ee9b310da6a1a0f013ef4e422fca30a685bcbec86a969bd520504e341"},
-    {file = "multidict-5.2.0-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:3bc3b1621b979621cee9f7b09f024ec76ec03cc365e638126a056317470bde1b"},
-    {file = "multidict-5.2.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:6ee908c070020d682e9b42c8f621e8bb10c767d04416e2ebe44e37d0f44d9ad5"},
-    {file = "multidict-5.2.0-cp39-cp39-win32.whl", hash = "sha256:1c7976cd1c157fa7ba5456ae5d31ccdf1479680dc9b8d8aa28afabc370df42b8"},
-    {file = "multidict-5.2.0-cp39-cp39-win_amd64.whl", hash = "sha256:c9631c642e08b9fff1c6255487e62971d8b8e821808ddd013d8ac058087591ac"},
-    {file = "multidict-5.2.0.tar.gz", hash = "sha256:0dd1c93edb444b33ba2274b66f63def8a327d607c6c790772f448a53b6ea59ce"},
-]
-nose = [
-    {file = "nose-1.3.7-py2-none-any.whl", hash = "sha256:dadcddc0aefbf99eea214e0f1232b94f2fa9bd98fa8353711dacb112bfcbbb2a"},
-    {file = "nose-1.3.7-py3-none-any.whl", hash = "sha256:9ff7c6cc443f8c51994b34a667bbcf45afd6d945be7477b52e97516fd17c53ac"},
-    {file = "nose-1.3.7.tar.gz", hash = "sha256:f1bffef9cbc82628f6e7d7b40d7e255aefaa1adb6a1b1d26c69a8b79e6208a98"},
-]
-numpy = [
-    {file = "numpy-1.21.4-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:8890b3360f345e8360133bc078d2dacc2843b6ee6059b568781b15b97acbe39f"},
-    {file = "numpy-1.21.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:69077388c5a4b997442b843dbdc3a85b420fb693ec8e33020bb24d647c164fa5"},
-    {file = "numpy-1.21.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e89717274b41ebd568cd7943fc9418eeb49b1785b66031bc8a7f6300463c5898"},
-    {file = "numpy-1.21.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0b78ecfa070460104934e2caf51694ccd00f37d5e5dbe76f021b1b0b0d221823"},
-    {file = "numpy-1.21.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:615d4e328af7204c13ae3d4df7615a13ff60a49cb0d9106fde07f541207883ca"},
-    {file = "numpy-1.21.4-cp310-cp310-win_amd64.whl", hash = "sha256:1403b4e2181fc72664737d848b60e65150f272fe5a1c1cbc16145ed43884065a"},
-    {file = "numpy-1.21.4-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:74b85a17528ca60cf98381a5e779fc0264b4a88b46025e6bcbe9621f46bb3e63"},
-    {file = "numpy-1.21.4-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:92aafa03da8658609f59f18722b88f0a73a249101169e28415b4fa148caf7e41"},
-    {file = "numpy-1.21.4-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:5d95668e727c75b3f5088ec7700e260f90ec83f488e4c0aaccb941148b2cd377"},
-    {file = "numpy-1.21.4-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f5162ec777ba7138906c9c274353ece5603646c6965570d82905546579573f73"},
-    {file = "numpy-1.21.4-cp37-cp37m-win32.whl", hash = "sha256:81225e58ef5fce7f1d80399575576fc5febec79a8a2742e8ef86d7b03beef49f"},
-    {file = "numpy-1.21.4-cp37-cp37m-win_amd64.whl", hash = "sha256:32fe5b12061f6446adcbb32cf4060a14741f9c21e15aaee59a207b6ce6423469"},
-    {file = "numpy-1.21.4-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:c449eb870616a7b62e097982c622d2577b3dbc800aaf8689254ec6e0197cbf1e"},
-    {file = "numpy-1.21.4-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:2e4ed57f45f0aa38beca2a03b6532e70e548faf2debbeb3291cfc9b315d9be8f"},
-    {file = "numpy-1.21.4-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:1247ef28387b7bb7f21caf2dbe4767f4f4175df44d30604d42ad9bd701ebb31f"},
-    {file = "numpy-1.21.4-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:34f3456f530ae8b44231c63082c8899fe9c983fd9b108c997c4b1c8c2d435333"},
-    {file = "numpy-1.21.4-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:4c9c23158b87ed0e70d9a50c67e5c0b3f75bcf2581a8e34668d4e9d7474d76c6"},
-    {file = "numpy-1.21.4-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e4799be6a2d7d3c33699a6f77201836ac975b2e1b98c2a07f66a38f499cb50ce"},
-    {file = "numpy-1.21.4-cp38-cp38-win32.whl", hash = "sha256:bc988afcea53e6156546e5b2885b7efab089570783d9d82caf1cfd323b0bb3dd"},
-    {file = "numpy-1.21.4-cp38-cp38-win_amd64.whl", hash = "sha256:170b2a0805c6891ca78c1d96ee72e4c3ed1ae0a992c75444b6ab20ff038ba2cd"},
-    {file = "numpy-1.21.4-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:fde96af889262e85aa033f8ee1d3241e32bf36228318a61f1ace579df4e8170d"},
-    {file = "numpy-1.21.4-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:c885bfc07f77e8fee3dc879152ba993732601f1f11de248d4f357f0ffea6a6d4"},
-    {file = "numpy-1.21.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:9e6f5f50d1eff2f2f752b3089a118aee1ea0da63d56c44f3865681009b0af162"},
-    {file = "numpy-1.21.4-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:ad010846cdffe7ec27e3f933397f8a8d6c801a48634f419e3d075db27acf5880"},
-    {file = "numpy-1.21.4-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:c74c699b122918a6c4611285cc2cad4a3aafdb135c22a16ec483340ef97d573c"},
-    {file = "numpy-1.21.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9864424631775b0c052f3bd98bc2712d131b3e2cd95d1c0c68b91709170890b0"},
-    {file = "numpy-1.21.4-cp39-cp39-win32.whl", hash = "sha256:b1e2312f5b8843a3e4e8224b2b48fe16119617b8fc0a54df8f50098721b5bed2"},
-    {file = "numpy-1.21.4-cp39-cp39-win_amd64.whl", hash = "sha256:e3c3e990274444031482a31280bf48674441e0a5b55ddb168f3a6db3e0c38ec8"},
-    {file = "numpy-1.21.4-pp37-pypy37_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:a3deb31bc84f2b42584b8c4001c85d1934dbfb4030827110bc36bfd11509b7bf"},
-    {file = "numpy-1.21.4.zip", hash = "sha256:e6c76a87633aa3fa16614b61ccedfae45b91df2767cf097aa9c933932a7ed1e0"},
-]
-pydantic = [
-    {file = "pydantic-1.8.2-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:05ddfd37c1720c392f4e0d43c484217b7521558302e7069ce8d318438d297739"},
-    {file = "pydantic-1.8.2-cp36-cp36m-manylinux1_i686.whl", hash = "sha256:a7c6002203fe2c5a1b5cbb141bb85060cbff88c2d78eccbc72d97eb7022c43e4"},
-    {file = "pydantic-1.8.2-cp36-cp36m-manylinux2014_i686.whl", hash = "sha256:589eb6cd6361e8ac341db97602eb7f354551482368a37f4fd086c0733548308e"},
-    {file = "pydantic-1.8.2-cp36-cp36m-manylinux2014_x86_64.whl", hash = "sha256:10e5622224245941efc193ad1d159887872776df7a8fd592ed746aa25d071840"},
-    {file = "pydantic-1.8.2-cp36-cp36m-win_amd64.whl", hash = "sha256:99a9fc39470010c45c161a1dc584997f1feb13f689ecf645f59bb4ba623e586b"},
-    {file = "pydantic-1.8.2-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:a83db7205f60c6a86f2c44a61791d993dff4b73135df1973ecd9eed5ea0bda20"},
-    {file = "pydantic-1.8.2-cp37-cp37m-manylinux1_i686.whl", hash = "sha256:41b542c0b3c42dc17da70554bc6f38cbc30d7066d2c2815a94499b5684582ecb"},
-    {file = "pydantic-1.8.2-cp37-cp37m-manylinux2014_i686.whl", hash = "sha256:ea5cb40a3b23b3265f6325727ddfc45141b08ed665458be8c6285e7b85bd73a1"},
-    {file = "pydantic-1.8.2-cp37-cp37m-manylinux2014_x86_64.whl", hash = "sha256:18b5ea242dd3e62dbf89b2b0ec9ba6c7b5abaf6af85b95a97b00279f65845a23"},
-    {file = "pydantic-1.8.2-cp37-cp37m-win_amd64.whl", hash = "sha256:234a6c19f1c14e25e362cb05c68afb7f183eb931dd3cd4605eafff055ebbf287"},
-    {file = "pydantic-1.8.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:021ea0e4133e8c824775a0cfe098677acf6fa5a3cbf9206a376eed3fc09302cd"},
-    {file = "pydantic-1.8.2-cp38-cp38-manylinux1_i686.whl", hash = "sha256:e710876437bc07bd414ff453ac8ec63d219e7690128d925c6e82889d674bb505"},
-    {file = "pydantic-1.8.2-cp38-cp38-manylinux2014_i686.whl", hash = "sha256:ac8eed4ca3bd3aadc58a13c2aa93cd8a884bcf21cb019f8cfecaae3b6ce3746e"},
-    {file = "pydantic-1.8.2-cp38-cp38-manylinux2014_x86_64.whl", hash = "sha256:4a03cbbe743e9c7247ceae6f0d8898f7a64bb65800a45cbdc52d65e370570820"},
-    {file = "pydantic-1.8.2-cp38-cp38-win_amd64.whl", hash = "sha256:8621559dcf5afacf0069ed194278f35c255dc1a1385c28b32dd6c110fd6531b3"},
-    {file = "pydantic-1.8.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:8b223557f9510cf0bfd8b01316bf6dd281cf41826607eada99662f5e4963f316"},
-    {file = "pydantic-1.8.2-cp39-cp39-manylinux1_i686.whl", hash = "sha256:244ad78eeb388a43b0c927e74d3af78008e944074b7d0f4f696ddd5b2af43c62"},
-    {file = "pydantic-1.8.2-cp39-cp39-manylinux2014_i686.whl", hash = "sha256:05ef5246a7ffd2ce12a619cbb29f3307b7c4509307b1b49f456657b43529dc6f"},
-    {file = "pydantic-1.8.2-cp39-cp39-manylinux2014_x86_64.whl", hash = "sha256:54cd5121383f4a461ff7644c7ca20c0419d58052db70d8791eacbbe31528916b"},
-    {file = "pydantic-1.8.2-cp39-cp39-win_amd64.whl", hash = "sha256:4be75bebf676a5f0f87937c6ddb061fa39cbea067240d98e298508c1bda6f3f3"},
-    {file = "pydantic-1.8.2-py3-none-any.whl", hash = "sha256:fec866a0b59f372b7e776f2d7308511784dace622e0992a0b59ea3ccee0ae833"},
-    {file = "pydantic-1.8.2.tar.gz", hash = "sha256:26464e57ccaafe72b7ad156fdaa4e9b9ef051f69e175dbbb463283000c05ab7b"},
-]
-python-dateutil = [
-    {file = "python-dateutil-2.8.2.tar.gz", hash = "sha256:0123cacc1627ae19ddf3c27a5de5bd67ee4586fbdd6440d9748f8abb483d3e86"},
-    {file = "python_dateutil-2.8.2-py2.py3-none-any.whl", hash = "sha256:961d03dc3453ebbc59dbdea9e4e11c5651520a876d0f4db161e8674aae935da9"},
-]
-requests = [
-    {file = "requests-2.26.0-py2.py3-none-any.whl", hash = "sha256:6c1246513ecd5ecd4528a0906f910e8f0f9c6b8ec72030dc9fd154dc1a6efd24"},
-    {file = "requests-2.26.0.tar.gz", hash = "sha256:b8aa58f8cf793ffd8782d3d8cb19e66ef36f7aba4353eec859e74678b01b07a7"},
-]
-requests-toolbelt = [
-    {file = "requests-toolbelt-0.9.1.tar.gz", hash = "sha256:968089d4584ad4ad7c171454f0a5c6dac23971e9472521ea3b6d49d610aa6fc0"},
-    {file = "requests_toolbelt-0.9.1-py2.py3-none-any.whl", hash = "sha256:380606e1d10dc85c3bd47bf5a6095f815ec007be7a8b69c878507068df059e6f"},
-]
-six = [
-    {file = "six-1.16.0-py2.py3-none-any.whl", hash = "sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254"},
-    {file = "six-1.16.0.tar.gz", hash = "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926"},
-]
-smmap = [
-    {file = "smmap-5.0.0-py3-none-any.whl", hash = "sha256:2aba19d6a040e78d8b09de5c57e96207b09ed71d8e55ce0959eeee6c8e190d94"},
-    {file = "smmap-5.0.0.tar.gz", hash = "sha256:c840e62059cd3be204b0c9c9f74be2c09d5648eddd4580d9314c3ecde0b30936"},
-]
-specklepy = [
-    {file = "specklepy-2.4.2-py3-none-any.whl", hash = "sha256:8906f69f4c3e7ba950873eb905b6e752c85d6aa2b2decb905165c6d401aebe20"},
-    {file = "specklepy-2.4.2.tar.gz", hash = "sha256:49fd6d8e1f2c6e190a0b6e85a08098984a8616eb46933b2516fcc769995452a6"},
-]
-svn = [
-    {file = "svn-1.0.1.tar.gz", hash = "sha256:55f81f07853cc1d66d4800b0cfe2d3376ff02361a2b2361459dc22a0fab95247"},
-]
-typing-extensions = [
-    {file = "typing_extensions-4.0.0-py3-none-any.whl", hash = "sha256:829704698b22e13ec9eaf959122315eabb370b0884400e9818334d8b677023d9"},
-    {file = "typing_extensions-4.0.0.tar.gz", hash = "sha256:2cdf80e4e04866a9b3689a51869016d36db0814d84b8d8a568d22781d45d27ed"},
-]
-ujson = [
-    {file = "ujson-4.3.0-cp310-cp310-macosx_10_14_x86_64.whl", hash = "sha256:3609e0514f6f721c6c9818b9374ec91b994e59fb193af2f924ca3f2f32009f1c"},
-    {file = "ujson-4.3.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:de42986e2602b6a0baca452ff50e9cbe66faf256761295d5d07ae3f6757b487d"},
-    {file = "ujson-4.3.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:843fd8b3246b2b20bbae48b2334d26507c9531b2b014533adfc6132e3ec8e60c"},
-    {file = "ujson-4.3.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5d1083a0dcb39b43cfcd948f09e480c23eb4af66d7d08f6b36951f4c629c3bd1"},
-    {file = "ujson-4.3.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:01d12df8eb25afb939a003284b5b5adca9788c1176c445641e5980fa892562ac"},
-    {file = "ujson-4.3.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:b0b9cde57eebaac26de040f8ebf0541e06fe9bcf7e42872dc036d2ced7d99ccf"},
-    {file = "ujson-4.3.0-cp310-cp310-win32.whl", hash = "sha256:3d8eaab72ad8129c12ed90ebf310230bd014b6bbf99145ebf2bc890238e0254f"},
-    {file = "ujson-4.3.0-cp310-cp310-win_amd64.whl", hash = "sha256:85f28c38952b8a94183ab15ec6c6e89c117d00ceeae5d754ef1a33e01e28b845"},
-    {file = "ujson-4.3.0-cp36-cp36m-macosx_10_14_x86_64.whl", hash = "sha256:8a0d9dde58937976cd06cd776411b77b0e5d38db0a3c1be28ee8bb428ff5a42b"},
-    {file = "ujson-4.3.0-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9f4a34386785a33600ac7442fec34c3d8b2d7e5309cfc94bc7c9ba93f12640c2"},
-    {file = "ujson-4.3.0-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d8e2a52fbeee55db306b9306892f5cde7e78c56069c1212abf176d1886fff60a"},
-    {file = "ujson-4.3.0-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9c5330692122b999997911252466a7d17e4e428d7d9a8db0b99ba81b8b9c010c"},
-    {file = "ujson-4.3.0-cp36-cp36m-musllinux_1_1_aarch64.whl", hash = "sha256:9baa160ba1d3f712a356e77718251c9d9eee43ed548debdcc9d75b06a75b3e82"},
-    {file = "ujson-4.3.0-cp36-cp36m-musllinux_1_1_x86_64.whl", hash = "sha256:a6c32356145d95a0403b5895d60c36798a48af13b8863e43ad7457a0361afad0"},
-    {file = "ujson-4.3.0-cp36-cp36m-win32.whl", hash = "sha256:b72fadeea5727204674c9f77166da7feaafdf70f1ed50bb15bf321f7c39c7194"},
-    {file = "ujson-4.3.0-cp36-cp36m-win_amd64.whl", hash = "sha256:1601354caaab0697a9b24815a31611ad013d29cf957d545fc1cd59835b82e3c1"},
-    {file = "ujson-4.3.0-cp37-cp37m-macosx_10_14_x86_64.whl", hash = "sha256:b80a35bad8fad1772f992bae8086b0cde788cd3b37f35d0d4506c93e6edad645"},
-    {file = "ujson-4.3.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7a318df321d7adc3de876b29640cca8de1ad4d4e4fe7c4a76d64d9d6f1676304"},
-    {file = "ujson-4.3.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fc9a508efb829bf0542be9b2578d8da08f0ab1fa712e086ebb777d6ec9e6d8d2"},
-    {file = "ujson-4.3.0-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:43d2403451d7bd27b6a600f89d4bd2cf6e1b3494254509d8b5ef3c8e94ae4d8e"},
-    {file = "ujson-4.3.0-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:fd0901db652a58f46550074596227dbddb7a02d2de744d3cd2358101f78037bb"},
-    {file = "ujson-4.3.0-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:00fd67952b1a8a46cf5b0a51b3838187332d13d2e8d178423c5a5405c21d9e7c"},
-    {file = "ujson-4.3.0-cp37-cp37m-win32.whl", hash = "sha256:b0e9510e867c72a87db2d16377c2bef912f29afd8381d1fdae332b9b7f697efa"},
-    {file = "ujson-4.3.0-cp37-cp37m-win_amd64.whl", hash = "sha256:294e907f134fb5d83e0a4439cf4040d74da77157938b4db5730cd174621dcf8b"},
-    {file = "ujson-4.3.0-cp38-cp38-macosx_10_14_x86_64.whl", hash = "sha256:087cd977f4f63f885a49607244e7e157801a22aadcc075a262d3c3633138573c"},
-    {file = "ujson-4.3.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4f35dcf6d2a67e913a7135809006bd000d55ad5b5834b5dbe5b82dcf8db1ac05"},
-    {file = "ujson-4.3.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f158fdb08e022f2f16f0fba317a80558b0cebc7e2c84ae783e5f75616d5c90d5"},
-    {file = "ujson-4.3.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2a06006dad34c8cfaa734bd6458452e46702b368da53b56e7732351082aa0420"},
-    {file = "ujson-4.3.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:6df94e675b05ecf4e7a57883a73b916ffcb5872d7b1298ac5cef8ac1cbce73c6"},
-    {file = "ujson-4.3.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:47af81df5d575e36d4be9396db94f35c8f62de3077a405f9af94f9756255cef5"},
-    {file = "ujson-4.3.0-cp38-cp38-win32.whl", hash = "sha256:e46c1462761db518fae51ab0d89a6256aeac148a795f7244d9084c459b477af5"},
-    {file = "ujson-4.3.0-cp38-cp38-win_amd64.whl", hash = "sha256:bf199015910fcfa19b6e12881abeb462498791b2ab0111ff8b17095d0477e9d4"},
-    {file = "ujson-4.3.0-cp39-cp39-macosx_10_14_x86_64.whl", hash = "sha256:32ee97ec37af31b35ca4395732d883bf74fb70309d38485f7fb9a5cc3332c53e"},
-    {file = "ujson-4.3.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f211c7c0c9377cbf4650aa990118d0c2cce3c5fad476c39ecd35b6714ba4463"},
-    {file = "ujson-4.3.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0c81159d3f1bcb5729ba019e63e78ee6c91b556e1ac0e67c7579768720fd3c4e"},
-    {file = "ujson-4.3.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b850029d64008e970cae04ada69aa33e1cd412106a1efde221269c1cda1b40cc"},
-    {file = "ujson-4.3.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:327ec982bb89abe779fe463e1013c47aae6ed53b76600af7cb1e8b8cb0ee9f85"},
-    {file = "ujson-4.3.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:103cbabe4e6fd70c957219519e37d65be612d7c74d91ef19022a2c8f8c5e4e82"},
-    {file = "ujson-4.3.0-cp39-cp39-win32.whl", hash = "sha256:7b0a63865ec2978ebafb0906bf982eb52bea26fc98e2ae5e59b9d204afe2d762"},
-    {file = "ujson-4.3.0-cp39-cp39-win_amd64.whl", hash = "sha256:18040475d997d93a6851d8bee474fba2ec94869e8f826dddd66cdae4aa3fdb92"},
-    {file = "ujson-4.3.0-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:df481d4e13ca34d870d1fdf387742867edff3f78a1eea1bbcd72ea2fa68d9a6e"},
-    {file = "ujson-4.3.0-pp37-pypy37_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e7e73ec5ba1b42c2027773f69b70eff28df132907aa98b28166c39d3ea45e85b"},
-    {file = "ujson-4.3.0-pp37-pypy37_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b270088e472f1d65a0a0aab3190010b9ac1a5b2969d39bf2b53c0fbf339bc87a"},
-    {file = "ujson-4.3.0.tar.gz", hash = "sha256:baee56eca35cb5fbe02c28bd9c0936be41a96fa5c0812d9d4b7edeb5c3d568a0"},
-]
-urllib3 = [
-    {file = "urllib3-1.26.7-py2.py3-none-any.whl", hash = "sha256:c4fdf4019605b6e5423637e01bc9fe4daef873709a7973e195ceba0a62bbc844"},
-    {file = "urllib3-1.26.7.tar.gz", hash = "sha256:4987c65554f7a2dbf30c18fd48778ef124af6fab771a377103da0585e2336ece"},
-]
-websockets = [
-    {file = "websockets-9.1-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:d144b350045c53c8ff09aa1cfa955012dd32f00c7e0862c199edcabb1a8b32da"},
-    {file = "websockets-9.1-cp36-cp36m-manylinux1_i686.whl", hash = "sha256:b4ad84b156cf50529b8ac5cc1638c2cf8680490e3fccb6121316c8c02620a2e4"},
-    {file = "websockets-9.1-cp36-cp36m-manylinux1_x86_64.whl", hash = "sha256:2cf04601633a4ec176b9cc3d3e73789c037641001dbfaf7c411f89cd3e04fcaf"},
-    {file = "websockets-9.1-cp36-cp36m-manylinux2010_i686.whl", hash = "sha256:5c8f0d82ea2468282e08b0cf5307f3ad022290ed50c45d5cb7767957ca782880"},
-    {file = "websockets-9.1-cp36-cp36m-manylinux2010_x86_64.whl", hash = "sha256:caa68c95bc1776d3521f81eeb4d5b9438be92514ec2a79fececda814099c8314"},
-    {file = "websockets-9.1-cp36-cp36m-manylinux2014_aarch64.whl", hash = "sha256:d2c2d9b24d3c65b5a02cac12cbb4e4194e590314519ed49db2f67ef561c3cf58"},
-    {file = "websockets-9.1-cp36-cp36m-win32.whl", hash = "sha256:f31722f1c033c198aa4a39a01905951c00bd1c74f922e8afc1b1c62adbcdd56a"},
-    {file = "websockets-9.1-cp36-cp36m-win_amd64.whl", hash = "sha256:3ddff38894c7857c476feb3538dd847514379d6dc844961dc99f04b0384b1b1b"},
-    {file = "websockets-9.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:51d04df04ed9d08077d10ccbe21e6805791b78eac49d16d30a1f1fe2e44ba0af"},
-    {file = "websockets-9.1-cp37-cp37m-manylinux1_i686.whl", hash = "sha256:f68c352a68e5fdf1e97288d5cec9296664c590c25932a8476224124aaf90dbcd"},
-    {file = "websockets-9.1-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:b43b13e5622c5a53ab12f3272e6f42f1ce37cd5b6684b2676cb365403295cd40"},
-    {file = "websockets-9.1-cp37-cp37m-manylinux2010_i686.whl", hash = "sha256:9147868bb0cc01e6846606cd65cbf9c58598f187b96d14dd1ca17338b08793bb"},
-    {file = "websockets-9.1-cp37-cp37m-manylinux2010_x86_64.whl", hash = "sha256:836d14eb53b500fd92bd5db2fc5894f7c72b634f9c2a28f546f75967503d8e25"},
-    {file = "websockets-9.1-cp37-cp37m-manylinux2014_aarch64.whl", hash = "sha256:48c222feb3ced18f3dc61168ca18952a22fb88e5eb8902d2bf1b50faefdc34a2"},
-    {file = "websockets-9.1-cp37-cp37m-win32.whl", hash = "sha256:900589e19200be76dd7cbaa95e9771605b5ce3f62512d039fb3bc5da9014912a"},
-    {file = "websockets-9.1-cp37-cp37m-win_amd64.whl", hash = "sha256:ab5ee15d3462198c794c49ccd31773d8a2b8c17d622aa184f669d2b98c2f0857"},
-    {file = "websockets-9.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:85e701a6c316b7067f1e8675c638036a796fe5116783a4c932e7eb8e305a3ffe"},
-    {file = "websockets-9.1-cp38-cp38-manylinux1_i686.whl", hash = "sha256:b2e71c4670ebe1067fa8632f0d081e47254ee2d3d409de54168b43b0ba9147e0"},
-    {file = "websockets-9.1-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:230a3506df6b5f446fed2398e58dcaafdff12d67fe1397dff196411a9e820d02"},
-    {file = "websockets-9.1-cp38-cp38-manylinux2010_i686.whl", hash = "sha256:7df3596838b2a0c07c6f6d67752c53859a54993d4f062689fdf547cb56d0f84f"},
-    {file = "websockets-9.1-cp38-cp38-manylinux2010_x86_64.whl", hash = "sha256:826ccf85d4514609219725ba4a7abd569228c2c9f1968e8be05be366f68291ec"},
-    {file = "websockets-9.1-cp38-cp38-manylinux2014_aarch64.whl", hash = "sha256:0dd4eb8e0bbf365d6f652711ce21b8fd2b596f873d32aabb0fbb53ec604418cc"},
-    {file = "websockets-9.1-cp38-cp38-win32.whl", hash = "sha256:1d0971cc7251aeff955aa742ec541ee8aaea4bb2ebf0245748fbec62f744a37e"},
-    {file = "websockets-9.1-cp38-cp38-win_amd64.whl", hash = "sha256:7189e51955f9268b2bdd6cc537e0faa06f8fffda7fb386e5922c6391de51b077"},
-    {file = "websockets-9.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:e9e5fd6dbdf95d99bc03732ded1fc8ef22ebbc05999ac7e0c7bf57fe6e4e5ae2"},
-    {file = "websockets-9.1-cp39-cp39-manylinux1_i686.whl", hash = "sha256:9e7fdc775fe7403dbd8bc883ba59576a6232eac96dacb56512daacf7af5d618d"},
-    {file = "websockets-9.1-cp39-cp39-manylinux1_x86_64.whl", hash = "sha256:597c28f3aa7a09e8c070a86b03107094ee5cdafcc0d55f2f2eac92faac8dc67d"},
-    {file = "websockets-9.1-cp39-cp39-manylinux2010_i686.whl", hash = "sha256:ad893d889bc700a5835e0a95a3e4f2c39e91577ab232a3dc03c262a0f8fc4b5c"},
-    {file = "websockets-9.1-cp39-cp39-manylinux2010_x86_64.whl", hash = "sha256:1d6b4fddb12ab9adf87b843cd4316c4bd602db8d5efd2fb83147f0458fe85135"},
-    {file = "websockets-9.1-cp39-cp39-manylinux2014_aarch64.whl", hash = "sha256:ebf459a1c069f9866d8569439c06193c586e72c9330db1390af7c6a0a32c4afd"},
-    {file = "websockets-9.1-cp39-cp39-win32.whl", hash = "sha256:be5fd35e99970518547edc906efab29afd392319f020c3c58b0e1a158e16ed20"},
-    {file = "websockets-9.1-cp39-cp39-win_amd64.whl", hash = "sha256:85db8090ba94e22d964498a47fdd933b8875a1add6ebc514c7ac8703eb97bbf0"},
-    {file = "websockets-9.1.tar.gz", hash = "sha256:276d2339ebf0df4f45df453923ebd2270b87900eda5dfd4a6b0cfa15f82111c3"},
-]
-yarl = [
-    {file = "yarl-1.7.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:f2a8508f7350512434e41065684076f640ecce176d262a7d54f0da41d99c5a95"},
-    {file = "yarl-1.7.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:da6df107b9ccfe52d3a48165e48d72db0eca3e3029b5b8cb4fe6ee3cb870ba8b"},
-    {file = "yarl-1.7.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a1d0894f238763717bdcfea74558c94e3bc34aeacd3351d769460c1a586a8b05"},
-    {file = "yarl-1.7.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dfe4b95b7e00c6635a72e2d00b478e8a28bfb122dc76349a06e20792eb53a523"},
-    {file = "yarl-1.7.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c145ab54702334c42237a6c6c4cc08703b6aa9b94e2f227ceb3d477d20c36c63"},
-    {file = "yarl-1.7.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1ca56f002eaf7998b5fcf73b2421790da9d2586331805f38acd9997743114e98"},
-    {file = "yarl-1.7.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:1d3d5ad8ea96bd6d643d80c7b8d5977b4e2fb1bab6c9da7322616fd26203d125"},
-    {file = "yarl-1.7.2-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:167ab7f64e409e9bdd99333fe8c67b5574a1f0495dcfd905bc7454e766729b9e"},
-    {file = "yarl-1.7.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:95a1873b6c0dd1c437fb3bb4a4aaa699a48c218ac7ca1e74b0bee0ab16c7d60d"},
-    {file = "yarl-1.7.2-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:6152224d0a1eb254f97df3997d79dadd8bb2c1a02ef283dbb34b97d4f8492d23"},
-    {file = "yarl-1.7.2-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:5bb7d54b8f61ba6eee541fba4b83d22b8a046b4ef4d8eb7f15a7e35db2e1e245"},
-    {file = "yarl-1.7.2-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:9c1f083e7e71b2dd01f7cd7434a5f88c15213194df38bc29b388ccdf1492b739"},
-    {file = "yarl-1.7.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:f44477ae29025d8ea87ec308539f95963ffdc31a82f42ca9deecf2d505242e72"},
-    {file = "yarl-1.7.2-cp310-cp310-win32.whl", hash = "sha256:cff3ba513db55cc6a35076f32c4cdc27032bd075c9faef31fec749e64b45d26c"},
-    {file = "yarl-1.7.2-cp310-cp310-win_amd64.whl", hash = "sha256:c9c6d927e098c2d360695f2e9d38870b2e92e0919be07dbe339aefa32a090265"},
-    {file = "yarl-1.7.2-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:9b4c77d92d56a4c5027572752aa35082e40c561eec776048330d2907aead891d"},
-    {file = "yarl-1.7.2-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c01a89a44bb672c38f42b49cdb0ad667b116d731b3f4c896f72302ff77d71656"},
-    {file = "yarl-1.7.2-cp36-cp36m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c19324a1c5399b602f3b6e7db9478e5b1adf5cf58901996fc973fe4fccd73eed"},
-    {file = "yarl-1.7.2-cp36-cp36m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3abddf0b8e41445426d29f955b24aeecc83fa1072be1be4e0d194134a7d9baee"},
-    {file = "yarl-1.7.2-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:6a1a9fe17621af43e9b9fcea8bd088ba682c8192d744b386ee3c47b56eaabb2c"},
-    {file = "yarl-1.7.2-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:8b0915ee85150963a9504c10de4e4729ae700af11df0dc5550e6587ed7891e92"},
-    {file = "yarl-1.7.2-cp36-cp36m-musllinux_1_1_aarch64.whl", hash = "sha256:29e0656d5497733dcddc21797da5a2ab990c0cb9719f1f969e58a4abac66234d"},
-    {file = "yarl-1.7.2-cp36-cp36m-musllinux_1_1_i686.whl", hash = "sha256:bf19725fec28452474d9887a128e98dd67eee7b7d52e932e6949c532d820dc3b"},
-    {file = "yarl-1.7.2-cp36-cp36m-musllinux_1_1_ppc64le.whl", hash = "sha256:d6f3d62e16c10e88d2168ba2d065aa374e3c538998ed04996cd373ff2036d64c"},
-    {file = "yarl-1.7.2-cp36-cp36m-musllinux_1_1_s390x.whl", hash = "sha256:ac10bbac36cd89eac19f4e51c032ba6b412b3892b685076f4acd2de18ca990aa"},
-    {file = "yarl-1.7.2-cp36-cp36m-musllinux_1_1_x86_64.whl", hash = "sha256:aa32aaa97d8b2ed4e54dc65d241a0da1c627454950f7d7b1f95b13985afd6c5d"},
-    {file = "yarl-1.7.2-cp36-cp36m-win32.whl", hash = "sha256:87f6e082bce21464857ba58b569370e7b547d239ca22248be68ea5d6b51464a1"},
-    {file = "yarl-1.7.2-cp36-cp36m-win_amd64.whl", hash = "sha256:ac35ccde589ab6a1870a484ed136d49a26bcd06b6a1c6397b1967ca13ceb3913"},
-    {file = "yarl-1.7.2-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:a467a431a0817a292121c13cbe637348b546e6ef47ca14a790aa2fa8cc93df63"},
-    {file = "yarl-1.7.2-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6ab0c3274d0a846840bf6c27d2c60ba771a12e4d7586bf550eefc2df0b56b3b4"},
-    {file = "yarl-1.7.2-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d260d4dc495c05d6600264a197d9d6f7fc9347f21d2594926202fd08cf89a8ba"},
-    {file = "yarl-1.7.2-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:fc4dd8b01a8112809e6b636b00f487846956402834a7fd59d46d4f4267181c41"},
-    {file = "yarl-1.7.2-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:c1164a2eac148d85bbdd23e07dfcc930f2e633220f3eb3c3e2a25f6148c2819e"},
-    {file = "yarl-1.7.2-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:67e94028817defe5e705079b10a8438b8cb56e7115fa01640e9c0bb3edf67332"},
-    {file = "yarl-1.7.2-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:89ccbf58e6a0ab89d487c92a490cb5660d06c3a47ca08872859672f9c511fc52"},
-    {file = "yarl-1.7.2-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:8cce6f9fa3df25f55521fbb5c7e4a736683148bcc0c75b21863789e5185f9185"},
-    {file = "yarl-1.7.2-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:211fcd65c58bf250fb994b53bc45a442ddc9f441f6fec53e65de8cba48ded986"},
-    {file = "yarl-1.7.2-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:c10ea1e80a697cf7d80d1ed414b5cb8f1eec07d618f54637067ae3c0334133c4"},
-    {file = "yarl-1.7.2-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:52690eb521d690ab041c3919666bea13ab9fbff80d615ec16fa81a297131276b"},
-    {file = "yarl-1.7.2-cp37-cp37m-win32.whl", hash = "sha256:695ba021a9e04418507fa930d5f0704edbce47076bdcfeeaba1c83683e5649d1"},
-    {file = "yarl-1.7.2-cp37-cp37m-win_amd64.whl", hash = "sha256:c17965ff3706beedafd458c452bf15bac693ecd146a60a06a214614dc097a271"},
-    {file = "yarl-1.7.2-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:fce78593346c014d0d986b7ebc80d782b7f5e19843ca798ed62f8e3ba8728576"},
-    {file = "yarl-1.7.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:c2a1ac41a6aa980db03d098a5531f13985edcb451bcd9d00670b03129922cd0d"},
-    {file = "yarl-1.7.2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:39d5493c5ecd75c8093fa7700a2fb5c94fe28c839c8e40144b7ab7ccba6938c8"},
-    {file = "yarl-1.7.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1eb6480ef366d75b54c68164094a6a560c247370a68c02dddb11f20c4c6d3c9d"},
-    {file = "yarl-1.7.2-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5ba63585a89c9885f18331a55d25fe81dc2d82b71311ff8bd378fc8004202ff6"},
-    {file = "yarl-1.7.2-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e39378894ee6ae9f555ae2de332d513a5763276a9265f8e7cbaeb1b1ee74623a"},
-    {file = "yarl-1.7.2-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:c0910c6b6c31359d2f6184828888c983d54d09d581a4a23547a35f1d0b9484b1"},
-    {file = "yarl-1.7.2-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:6feca8b6bfb9eef6ee057628e71e1734caf520a907b6ec0d62839e8293e945c0"},
-    {file = "yarl-1.7.2-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:8300401dc88cad23f5b4e4c1226f44a5aa696436a4026e456fe0e5d2f7f486e6"},
-    {file = "yarl-1.7.2-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:788713c2896f426a4e166b11f4ec538b5736294ebf7d5f654ae445fd44270832"},
-    {file = "yarl-1.7.2-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:fd547ec596d90c8676e369dd8a581a21227fe9b4ad37d0dc7feb4ccf544c2d59"},
-    {file = "yarl-1.7.2-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:737e401cd0c493f7e3dd4db72aca11cfe069531c9761b8ea474926936b3c57c8"},
-    {file = "yarl-1.7.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:baf81561f2972fb895e7844882898bda1eef4b07b5b385bcd308d2098f1a767b"},
-    {file = "yarl-1.7.2-cp38-cp38-win32.whl", hash = "sha256:ede3b46cdb719c794427dcce9d8beb4abe8b9aa1e97526cc20de9bd6583ad1ef"},
-    {file = "yarl-1.7.2-cp38-cp38-win_amd64.whl", hash = "sha256:cc8b7a7254c0fc3187d43d6cb54b5032d2365efd1df0cd1749c0c4df5f0ad45f"},
-    {file = "yarl-1.7.2-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:580c1f15500e137a8c37053e4cbf6058944d4c114701fa59944607505c2fe3a0"},
-    {file = "yarl-1.7.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:3ec1d9a0d7780416e657f1e405ba35ec1ba453a4f1511eb8b9fbab81cb8b3ce1"},
-    {file = "yarl-1.7.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:3bf8cfe8856708ede6a73907bf0501f2dc4e104085e070a41f5d88e7faf237f3"},
-    {file = "yarl-1.7.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1be4bbb3d27a4e9aa5f3df2ab61e3701ce8fcbd3e9846dbce7c033a7e8136746"},
-    {file = "yarl-1.7.2-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:534b047277a9a19d858cde163aba93f3e1677d5acd92f7d10ace419d478540de"},
-    {file = "yarl-1.7.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c6ddcd80d79c96eb19c354d9dca95291589c5954099836b7c8d29278a7ec0bda"},
-    {file = "yarl-1.7.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:9bfcd43c65fbb339dc7086b5315750efa42a34eefad0256ba114cd8ad3896f4b"},
-    {file = "yarl-1.7.2-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:f64394bd7ceef1237cc604b5a89bf748c95982a84bcd3c4bbeb40f685c810794"},
-    {file = "yarl-1.7.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:044daf3012e43d4b3538562da94a88fb12a6490652dbc29fb19adfa02cf72eac"},
-    {file = "yarl-1.7.2-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:368bcf400247318382cc150aaa632582d0780b28ee6053cd80268c7e72796dec"},
-    {file = "yarl-1.7.2-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:bab827163113177aee910adb1f48ff7af31ee0289f434f7e22d10baf624a6dfe"},
-    {file = "yarl-1.7.2-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:0cba38120db72123db7c58322fa69e3c0efa933040ffb586c3a87c063ec7cae8"},
-    {file = "yarl-1.7.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:59218fef177296451b23214c91ea3aba7858b4ae3306dde120224cfe0f7a6ee8"},
-    {file = "yarl-1.7.2-cp39-cp39-win32.whl", hash = "sha256:1edc172dcca3f11b38a9d5c7505c83c1913c0addc99cd28e993efeaafdfaa18d"},
-    {file = "yarl-1.7.2-cp39-cp39-win_amd64.whl", hash = "sha256:797c2c412b04403d2da075fb93c123df35239cd7b4cc4e0cd9e5839b73f52c58"},
-    {file = "yarl-1.7.2.tar.gz", hash = "sha256:45399b46d60c253327a460e99856752009fcee5f5d3c80b2f7c0cae1c38d56dd"},
-]

pyproject.toml

@@ -1,20 +1,14 @@
-[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>"]
+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.0a11"]
 
-[tool.poetry.dependencies]
-python = ">=3.7,<3.8"
-specklepy = "2.4.2"
+[dependency-groups]
+dev = [
+    "fake-bpy-module-latest>=20240524,<20240525",
+    "ruff>=0.4.4,<0.5",
+]
 
-[tool.poetry.dev-dependencies]
-devtools = "^0.6.1"
-numpy = "^1.20.2"
-bpy = "^2.82.1"
-bpy-build = "^2.1.0"
-
-[build-system]
-requires = ["poetry-core>=1.0.0"]
-build-backend = "poetry.core.masonry.api"

uv.lock

@@ -0,0 +1,700 @@
+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.0a4" }]
+
+[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.0a4"
+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 = "ujson" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d9/40/0df270e2b0eb4a58ebfcef396261a20e2d9d89518269f770d136b1e0885b/specklepy-3.0.0a4.tar.gz", hash = "sha256:36164e90f4b018f89837d4200ca0260c13b833c6f2569cc53a4024bf0657a2d0", size = 201224 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/38/90/6db2f012fde0618142449801854549b4aab91cb3b821ba01d40f79160f11/specklepy-3.0.0a4-py3-none-any.whl", hash = "sha256:776ae24e1f010c8830dbb5c3c0c53707a43fb42a43cbf9fb8d5c6081f2d7b457", size = 113919 },
+]
+
+[[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 },
+]