feat(api): Added functions for fetching the connector version feeds. (#435)

* Added connector feed utility functions

* Check ex code

.circleci/config.yml

@@ -1,78 +1,17 @@
 version: 2.1
 
-orbs:
+# Define the jobs we want to run for this project
-  python: circleci/python@1.3.2
-  codecov: codecov/codecov@3.2.2
-
 jobs:
-  test:
+  build:
     docker:
-      - image: "cimg/python:<<parameters.tag>>"
+      - image: cimg/base:2023.03
-      - image: 'cimg/node:14.18'
-      - image: 'circleci/redis:6'
-      - image: 'cimg/postgres:12.8'
-        environment:
-          POSTGRES_DB: speckle2_test
-          POSTGRES_PASSWORD: speckle
-          POSTGRES_USER: speckle
-      - image: "speckle/speckle-server"
-        command: ["bash", "-c", "/wait && node bin/www"]
-        environment:
-          POSTGRES_URL: "localhost"
-          POSTGRES_USER: "speckle"
-          POSTGRES_PASSWORD: "speckle"
-          POSTGRES_DB: "speckle2_test"
-          REDIS_URL: "redis://localhost"
-          SESSION_SECRET: "keyboard cat"
-          STRATEGY_LOCAL: "true"
-          CANONICAL_URL: "http://localhost:3000"
-          WAIT_HOSTS: localhost:5432, localhost:6379
-    parameters:
-      tag:
-        default: "3.8"
-        type: string
     steps:
-      - checkout
+      - run: echo "so long and thanks for all the fish"
-      - run: python --version
-      - run:
-          command: python -m pip install --upgrade pip
-          name: upgrade pip
-      - python/install-packages:
-          pkg-manager: poetry
-      - run: poetry run pytest --cov --cov-report xml:reports/coverage.xml --junitxml=reports/test-results.xml
-
-      - store_test_results:
-          path: reports
-
-      - store_artifacts:
-          path: reports
-
-      - codecov/upload
-
-  deploy:
-    docker:
-      - image: "circleci/python:3.8"
-    steps:
-      - checkout
-      - run: python patch_version.py $CIRCLE_TAG
-      - run: poetry build
-      - run: poetry publish -u specklesystems -p $PYPI_PASSWORD
 
+# Orchestrate our job run sequence
 workflows:
-  main:
+  build_and_test:
-    jobs: 
+    when:
-      - test:
+      false
-          matrix:
+    jobs:
-            parameters:
+      - build
-              tag: ["3.6", "3.7", "3.8", "3.9"]
-          filters:
-            tags:
-              only: /.*/
-      - deploy:
-          requires:
-            - test 
-          filters:
-            tags:
-              only: /[0-9]+(\.[0-9]+)*/
-            branches:
-              ignore: /.*/ # For testing only! /ci\/.*/

.gitattributes

@@ -0,0 +1,3 @@
+* text=auto eol=lf
+*.{cmd,[cC][mM][dD]} text eol=crlf
+*.{bat,[bB][aA][tT]} text eol=crlf

.github/ISSUE_TEMPLATE/ISSUE_TEMPLATE.md

@@ -1,25 +0,0 @@
----
-name: New issue
-about: Create a report to help us improve
-title:
-labels:
-assignees:
----
-
-If it's your first time here - or you forgot about them - make sure you read the [contribution guidelines](CONTRIBUTING.md), and then feel free to delete this line!
-
-### Expected vs. Actual Behavior
-
-Describe the problem here.
-
-### Reproduction Steps & System Config (win, osx, web, etc.)
-
-Let us know how we can reproduce this, and attach relevant files (if any).
-
-### Proposed Solution (if any)
-
-Let us know what how you would solve this.
-
-#### Optional: Affected Projects
-
-Does this issue propagate to other dependencies or dependents? If so, list them here!

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,113 @@
+---
+name: Bug report
+about: Help improve Speckle!
+title: ''
+labels: bug
+assignees: ''
+---
+
+<!---
+
+Provide a short summary in the Title above. Examples of good Issue titles:
+
+* "Bug: Error from server when reticulating splines"
+* "Bug: Revit crashes when installing connector"
+
+-->
+
+## Prerequisites
+
+<!---
+
+Please answer the following questions before submitting an issue.
+
+-->
+
+- [ ] I read the [contribution guidelines](https://github.com/specklesystems/speckle-server/blob/main/CONTRIBUTING.md)
+- [ ] I checked the [documentation](https://speckle.guide/) and found no answer.
+- [ ] I checked [existing issues](../issues?q=is%3Aissue) and found no similar issue. <!-- If you do find an existing issue, please show your support by liking it :+1: instead of creating a new issue -->
+- [ ] I checked the [community forum](https://speckle.community/) for related discussions and found no answer.
+- [ ] I'm reporting the issue to the correct repository (see also [speckle-server](https://github.com/specklesystems/speckle-server), [speckle-sharp](https://github.com/specklesystems/speckle-sharp), [specklepy](https://github.com/specklesystems/specklepy), [speckle-docs](https://github.com/specklesystems/speckle-docs), and [others](https://github.com/orgs/specklesystems/repositories))
+
+## What package are you referring to?
+
+<!---
+Is it related to the server (backend) only, or does this bug relate to the frontend, viewer, objectloader or any other package?
+-->
+
+## Describe the bug
+
+<!---
+A clear and concise description of what the bug is.
+-->
+
+## To Reproduce
+
+<!---
+Steps to reproduce the behavior:
+
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+-->
+
+## Expected behavior
+
+<!---
+A clear and concise description of what you expected to happen.
+-->
+
+## Screenshots
+
+<!---
+If applicable, add screenshots to help explain your problem.
+-->
+
+## System Info
+
+If applicable, please fill in the below details - they help a lot!
+
+### Desktop (please complete the following information):
+
+- OS: [e.g. iOS]
+- Browser [e.g. chrome, safari]
+- Version [e.g. 22]
+
+### Smartphone (please complete the following information):
+
+- Device: [e.g. iPhone6]
+- OS: [e.g. iOS8.1]
+- Browser [e.g. stock browser, safari]
+- Version [e.g. 22]
+
+## Failure Logs
+
+<!---
+Please include any relevant log snippets or files here, or upload as a file.
+
+If including inline, please use markdown code block syntax. https://docs.github.com/en/get-started/writing-on-github/working-with-advanced-formatting/creating-and-highlighting-code-blocks
+For example:
+
+```
+your log output here
+```
+-->
+
+## Additional context
+
+<!---
+Add any other context about the problem here.
+-->
+
+## Proposed Solution (if any)
+
+<!---
+Let us know what how you would solve this.
+-->
+
+#### Optional: Affected Projects
+
+<!---
+Does this issue propagate to other dependencies or dependents? If so, list them here with links!
+-->

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,71 @@
+---
+name: Feature request
+about: Suggest an idea for Speckle!
+title: ''
+labels: enhancement, question
+assignees: ''
+---
+
+<!---
+
+Provide a short summary in the Title above. Examples of good Issue titles:
+
+* "Enhancement: Connector for Minecraft"
+* "Enhancement: Web viewer should support tesseracts"
+
+-->
+
+## Prerequisites
+
+<!---
+
+Please answer the following questions before submitting an issue.
+
+-->
+
+- [ ] I read the [contribution guidelines](https://github.com/specklesystems/speckle-server/blob/main/CONTRIBUTING.md)
+- [ ] I checked the [documentation](https://speckle.guide/) and found no answer.
+- [ ] I checked [existing issues](../issues?q=is%3Aissue) and found no similar issue. <!-- If you do find an existing issue, please show your support by liking it :+1: instead of creating a new issue -->
+- [ ] I checked the [community forum](https://speckle.community/) for related discussions and found no answer.
+- [ ] I'm requesting the feature to the correct repository (see also [speckle-server](https://github.com/specklesystems/speckle-server), [speckle-sharp](https://github.com/specklesystems/speckle-sharp), [specklepy](https://github.com/specklesystems/specklepy), [speckle-docs](https://github.com/specklesystems/speckle-docs), and [others](https://github.com/orgs/specklesystems/repositories))
+
+## What package are you referring to?
+
+<!---
+Is it related to the server (backend) only, or does this feature request relate to the frontend, viewer, objectloader or any other package?
+-->
+
+## Is your feature request related to a problem? Please describe.
+
+<!---
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+-->
+
+## Describe the solution you'd like
+
+<!---
+A clear and concise description of what you want to happen.
+-->
+
+## Describe alternatives you've considered
+
+<!---
+A clear and concise description of any alternative solutions or features you've considered.
+-->
+
+## Additional context
+
+<!---
+Add any other context or screenshots about the feature request here.
+
+Have you seen this feature implemented in any other software?  Can you provide screenshots or links to video or documentation?
+What works well about these existing features in other software?  What doesn't work well?
+-->
+
+## Related issues or community discussions
+
+<!---
+Is this feature request related to (but sufficiently distinct from) any existing issues?
+Does this feature request require other features to be available beforehand?
+Has this feature been discussed in the community forum, please link here? https://speckle.community/
+-->

.github/PULL_REQUEST_TEMPLATE/PR_TEMPLATE.md

@@ -1,25 +0,0 @@
-Description of PR...
-
-## Changes
-
-- Item 1
-- Item 2
-
-## Checklist
-
-- [ ] Unit tests
-- [ ] Documentation
-
-## References
-
-(optional)
-
-Include **important** links regarding the implementation of this PR.
-This usually includes and RFC or an aggregation of issues and/or individual conversations
-that helped put this solution together. This helps ensure there is a good aggregation
-of resources regarding the implementation.
-
-```text
-Fixes #85, Fixes #22, Fixes username/repo#123
-Connects #123
-```

.github/pull_request_template.md

@@ -0,0 +1,102 @@
+<!---
+
+Provide a short summary in the Title above. Examples of good PR titles:
+
+* "Feature: adds metrics to component"
+
+* "Fix: resolves duplication in comment thread"
+
+* "Update: apollo v2.34.0"
+
+-->
+
+## Description & motivation
+
+<!---
+
+Describe your changes, and why you're making them.  What benefit will this have to others?
+
+Is this linked to an open Github issue, a thread in Speckle community,
+or another pull request? Link it here.
+
+If it is related to a Github issue, and resolves it, please link to the issue number, e.g.:
+Fixes #85, Fixes #22, Fixes username/repo#123
+Connects #123
+
+-->
+
+## Changes:
+
+<!---
+
+- Item 1
+- Item 2
+
+-->
+
+## To-do before merge:
+
+<!---
+
+(Optional -- remove this section if not needed)
+
+Include any notes about things that need to happen before this PR is merged, e.g.:
+
+- [ ] Change the base branch
+
+- [ ] Ensure PR #56 is merged
+
+-->
+
+## Screenshots:
+
+<!---
+
+Include a screenshot the before and after.  This can be a screenshot of a plugin, web frontend, or output in a terminal.
+
+-->
+
+## Validation of changes:
+
+<!---
+
+Describe what tests have been added or amended, and why these demonstrate it works and will prevent this feature being accidentally broken by future changes.
+
+-->
+
+## Checklist:
+
+<!---
+
+This checklist is mostly useful as a reminder of small things that can easily be
+
+forgotten – it is meant as a helpful tool rather than hoops to jump through.
+
+Put an `x` between the square brackets, e.g. [x], for all the items that apply,
+
+make notes next to any that haven't been addressed, and remove any items that are not relevant to this PR.
+
+-->
+
+- [ ] My pull request follows the guidelines in the [Contributing guide](https://github.com/specklesystems/speckle-server/blob/main/CONTRIBUTING.md)?
+- [ ] My pull request does not duplicate any other open [Pull Requests](../../pulls) for the same update/change?
+- [ ] My commits are related to the pull request and do not amend unrelated code or documentation.
+- [ ] My code follows a similar style to existing code.
+- [ ] I have added appropriate tests.
+- [ ] I have updated or added relevant documentation.
+
+## References
+
+<!---
+
+(Optional -- remove this section if not needed )
+
+Include **important** links regarding the implementation of this PR.
+
+This usually includes a RFC or an aggregation of issues and/or individual conversations
+
+that helped put this solution together. This helps ensure we retain and share knowledge
+
+regarding the implementation, and may help others understand motivation and design decisions etc..
+
+-->

.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,58 @@
+name: "Specklepy test"
+on:
+  workflow_call:
+    secrets:
+      CODECOV_TOKEN:
+        required: true
+  pull_request:
+    branches:
+      - "main"
+
+jobs:
+  test:
+    name: test
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version:
+          - "3.10"
+          - "3.11"
+          - "3.12"
+          - "3.13"
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv and set the python version
+        uses: astral-sh/setup-uv@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          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: Run Speckle Server
+        run: docker compose up --detach --wait
+
+      - name: Run tests
+        run: uv run pytest --cov --cov-report xml:reports/coverage.xml --junitxml=reports/test-results.xml
+
+      - uses: codecov/codecov-action@v5
+        if: matrix.python-version == 3.13
+        with:
+          fail_ci_if_error: true # optional (default = false)
+          files: ./reports/test-results.xml # optional
+          token: ${{ secrets.CODECOV_TOKEN }}
+
+      - name: Minimize uv cache
+        run: uv cache prune --ci

.github/workflows/publish.yml

@@ -0,0 +1,55 @@
+name: "Publish Python Package"
+on:
+  push:
+    branches:
+      - "main"
+    tags:
+      - "3.*.*"
+
+jobs:
+  test:
+    uses: "./.github/workflows/pr.yml"
+    secrets:
+      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+
+  publish-package:
+    name: "Build and Publish Python Package"
+    runs-on: ubuntu-latest
+    needs: test
+
+    # set the environment based on what triggered the workflow
+    environment:
+      name: ${{ github.ref_type == 'tag' && 'pypi' || 'testpypi' }}
+
+    permissions:
+      id-token: write
+
+    steps:
+      - name: "Install uv"
+        uses: astral-sh/setup-uv@v5
+
+      - name: "Checkout code"
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: "Build package artifacts"
+        run: uv build
+
+      # Logic for TestPyPI (on main branch push)
+      - name: "Publish to TestPyPI"
+        if: ${{ github.ref_type == 'branch' }}
+        run: uv publish --index test
+
+      - name: "Verify TestPyPI package installation"
+        if: ${{ github.ref_type == 'branch' }}
+        run: uv run --index test --with specklepy --no-project -- python -c "import specklepy"
+
+      # Logic for PyPI (on v3* tag creation)
+      - name: "Publish to PyPI"
+        if: ${{ github.ref_type == 'tag' }}
+        run: uv publish
+
+      - name: "Verify PyPI package installation"
+        if: ${{ github.ref_type == 'tag' }}
+        run: uv run --with specklepy --no-project -- python -c "import specklepy"

.gitignore

@@ -2,6 +2,8 @@
 .envrc
 reports/
 
+.volumes/
+
 # Byte-compiled / optimized / DLL files
 __pycache__/
 *.py[cod]
@@ -112,4 +114,4 @@ venv.bak/
 
 # other
 scratch.py
-settings.json
+settings.json

.pre-commit-config.yaml

@@ -0,0 +1,31 @@
+repos:
+  - repo: local
+    hooks:
+      # Run the linter.
+      - id: ruff
+        name: ruff lint
+        entry: uv run ruff check --force-exclude
+        language: system
+        types_or: [python, pyi]
+      # Run the formatter.
+      - id: ruff-format
+        name: ruff format
+        entry: uv run ruff format --force-exclude
+        language: system
+        types_or: [python, pyi]
+
+
+  - repo: https://github.com/commitizen-tools/commitizen
+    hooks:
+      - id: commitizen
+      - id: commitizen-branch
+        stages:
+          - pre-push
+    rev: v3.13.0
+
+
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+      - id: end-of-file-fixer
+      - id: trailing-whitespace

.vscode/launch.json

@@ -6,17 +6,20 @@
   "configurations": [
     {
       "name": "Python: Current File",
-      "type": "python",
+      "type": "debugpy",
       "request": "launch",
       "program": "${file}",
       "console": "integratedTerminal",
       "justMyCode": false
     },
     {
-      "name": "Python: Test debug config",
+      "name": "Pytest",
-      "type": "python",
+      "type": "debugpy",
-      "request": "test",
+      "request": "launch",
+      "module": "pytest",
+      "args": [],
       "console": "integratedTerminal",
+      "justMyCode": true
     }
   ]
-}
+}

README.md

@@ -2,52 +2,22 @@
   <img src="https://user-images.githubusercontent.com/2679513/131189167-18ea5fe1-c578-47f6-9785-3748178e4312.png" width="150px"/><br/>
   Speckle | specklepy 🐍
 </h1>
+
+<p align="center"><a href="https://twitter.com/SpeckleSystems"><img src="https://img.shields.io/twitter/follow/SpeckleSystems?style=social" alt="Twitter Follow"></a> <a href="https://speckle.community"><img src="https://img.shields.io/discourse/users?server=https%3A%2F%2Fspeckle.community&amp;style=flat-square&amp;logo=discourse&amp;logoColor=white" alt="Community forum users"></a> <a href="https://speckle.systems"><img src="https://img.shields.io/badge/https://-speckle.systems-royalblue?style=flat-square" alt="website"></a> <a href="https://speckle.guide/dev/"><img src="https://img.shields.io/badge/docs-speckle.guide-orange?style=flat-square&amp;logo=read-the-docs&amp;logoColor=white" alt="docs"></a></p>
+
+> Speckle is the first AEC data hub that connects with your favorite AEC tools. Speckle exists to overcome the challenges of working in a fragmented industry where communication, creative workflows, and the exchange of data are often hindered by siloed software and processes. It is here to make the industry better.
+
 <h3 align="center">
     The Python SDK
 </h3>
-<p align="center"><b>Speckle</b> is the data infrastructure for the AEC industry.</p><br/>
-
-<p align="center"><a href="https://twitter.com/SpeckleSystems"><img src="https://img.shields.io/twitter/follow/SpeckleSystems?style=social" alt="Twitter Follow"></a> <a href="https://speckle.community"><img src="https://img.shields.io/discourse/users?server=https%3A%2F%2Fspeckle.community&amp;style=flat-square&amp;logo=discourse&amp;logoColor=white" alt="Community forum users"></a> <a href="https://speckle.systems"><img src="https://img.shields.io/badge/https://-speckle.systems-royalblue?style=flat-square" alt="website"></a> <a href="https://speckle.guide/dev/"><img src="https://img.shields.io/badge/docs-speckle.guide-orange?style=flat-square&amp;logo=read-the-docs&amp;logoColor=white" alt="docs"></a></p>
-<p align="center"><a href="https://github.com/specklesystems/specklepy/"><img src="https://circleci.com/gh/specklesystems/specklepy.svg?style=svg&amp;circle-token=76eabd350ea243575cbb258b746ed3f471f7ac29" alt="Speckle-Next"></a><a href="https://codecov.io/gh/specklesystems/specklepy">
-  <img src="https://codecov.io/gh/specklesystems/specklepy/branch/main/graph/badge.svg?token=8KQFL5N0YF"/>
-</a> </p>
-
-# About Speckle
-
-What is Speckle? Check our ![YouTube Video Views](https://img.shields.io/youtube/views/B9humiSpHzM?label=Speckle%20in%201%20minute%20video&style=social)
-
-### Features
-
-- **Object-based:** say goodbye to files! Speckle is the first object based platform for the AEC industry
-- **Version control:** Speckle is the Git & Hub for geometry and BIM data
-- **Collaboration:** share your designs collaborate with others
-- **3D Viewer:** see your CAD and BIM models online, share and embed them anywhere
-- **Interoperability:** get your CAD and BIM models into other software without exporting or importing
-- **Real time:** get real time updates and notifications and changes
-- **GraphQL API:** get what you need anywhere you want it
-- **Webhooks:** the base for a automation and next-gen pipelines
-- **Built for developers:** we are building Speckle with developers in mind and got tools for every stack
-- **Built for the AEC industry:** Speckle connectors are plugins for the most common software used in the industry such as Revit, Rhino, Grasshopper, AutoCAD, Civil 3D, Excel, Unreal Engine, Unity, QGIS, Blender and more!
-
-### Try Speckle now!
-
-Give Speckle a try in no time by:
-
-- [![speckle XYZ](https://img.shields.io/badge/https://-speckle.xyz-0069ff?style=flat-square&logo=hackthebox&logoColor=white)](https://speckle.xyz) ⇒ creating an account at our public server
-- [![create a droplet](https://img.shields.io/badge/Create%20a%20Droplet-0069ff?style=flat-square&logo=digitalocean&logoColor=white)](https://marketplace.digitalocean.com/apps/speckle-server?refcode=947a2b5d7dc1) ⇒ deploying an instance in 1 click 
-
-### Resources
-
-- [![Community forum users](https://img.shields.io/badge/community-forum-green?style=for-the-badge&logo=discourse&logoColor=white)](https://speckle.community) for help, feature requests or just to hang with other speckle enthusiasts, check out our community forum!
-- [![website](https://img.shields.io/badge/tutorials-speckle.systems-royalblue?style=for-the-badge&logo=youtube)](https://speckle.systems) our tutorials portal is full of resources to get you started using Speckle
-- [![docs](https://img.shields.io/badge/docs-speckle.guide-orange?style=for-the-badge&logo=read-the-docs&logoColor=white)](https://speckle.guide/dev/) reference on almost any end-user and developer functionality
 
+<p align="center"><a href="https://codecov.io/gh/specklesystems/specklepy"><img src="https://codecov.io/gh/specklesystems/specklepy/branch/main/graph/badge.svg?token=8KQFL5N0YF" alt="Codecov"></a></p>
 
 # Repo structure
 
 ## Usage
 
-Send and receive data from a Speckle Server with `operations`, interact with the Speckle API with the `SpeckleClient`, create and extend your own custom Speckle Objects with `Base`, and more! 
+Send and receive data from a Speckle Server with `operations`, interact with the Speckle API with the `SpeckleClient`, create and extend your own custom Speckle Objects with `Base`, and more!
 
 Head to the [**📚 specklepy docs**](https://speckle.guide/dev/python.html) for more information and usage examples.
 
@@ -55,26 +25,32 @@ Head to the [**📚 specklepy docs**](https://speckle.guide/dev/python.html) for
 
 ### Installation
 
-This project uses python-poetry for dependency management, make sure you follow the official [docs](https://python-poetry.org/docs/#installation) to get poetry.
+This project uses uv for dependency management, make sure you follow the official [docs](https://docs.astral.sh/uv/) to get it.
 
-To bootstrap the project environment run `$ poetry install`. This will create a new virtual-env for the project and install both the package and dev dependencies.
+To create a new virtual environment with uv run `$ uv venv` and follow the instructions on the screen to activate the virtual environment.
+To bootstrap the project environment run `$ uv sync`. This will install both the package and dev dependencies.
 
-If this is your first time using poetry and you're used to creating your venvs within the project directory, run `poetry config virtualenvs.in-project true` to configure poetry to do the same.
+To execute any python script run `$ uv run python my_script.py`
 
-To execute any python script run `$ poetry run python my_script.py`
+> Alternatively you may roll your own virtual-env with either venv, virtualenv, pyenv-virtualenv etc. Uv will play along an recognize if it is invoked from inside a virtual environment.
 
-> Alternatively you may roll your own virtual-env with either venv, virtualenv, pyenv-virtualenv etc. Poetry will play along an recognize if it is invoked from inside a virtual environment.
+### Style guide
+
+All our repo wide styling linting and other rules are checked and enforced by `pre-commit`, which is included in the dev dependencies.
+It is recommended to set up `pre-commit` after installing the dependencies by running `$ pre-commit install`.
+Commiting code that doesn't adhere to the given rules, will fail the checks in our CI system.
 
 ### Local Data Paths
 
 It may be helpful to know where the local accounts and object cache dbs are stored. Depending on on your OS, you can find the dbs at:
+
 - Windows: `APPDATA` or `<USER>\AppData\Roaming\Speckle`
 - Linux: `$XDG_DATA_HOME` or by default `~/.local/share/Speckle`
 - Mac: `~/.config/Speckle`
 
 ## Contributing
 
-Please make sure you read the [contribution guidelines](.github/CONTRIBUTING.md) for an overview of the best practices we try to follow.
+Please make sure you read the [contribution guidelines](.github/CONTRIBUTING.md) and [code of conduct](.github/CODE_OF_CONDUCT.md) for an overview of the practices we try to follow.
 
 ## Community
 
@@ -82,7 +58,7 @@ The Speckle Community hangs out on [the forum](https://discourse.speckle.works),
 
 ## Security
 
-For any security vulnerabilities or concerns, please contact us directly at security[at]speckle.systems. 
+For any security vulnerabilities or concerns, please contact us directly at security[at]speckle.systems.
 
 ## License
 

SECURITY.md

@@ -0,0 +1,12 @@
+# Security Policy
+
+## Supported Versions
+
+| Version | Supported          |
+| ------- | ------------------ |
+| 2.2.+   | :white_check_mark: |
+| < 2.2   | :x:                |
+
+## Reporting a Vulnerability
+
+Hi! If you've found something off, we'd be more than happy if you would report it via security@speckle.systems. We will work together with you to correctly identify the cause and implement a fix. Thanks for helping make Speckle safer!

docker-compose.yml

@@ -0,0 +1,111 @@
+version: "3.9"
+name: "speckle-server"
+
+services:
+  ####
+  # Speckle Server dependencies
+  #######
+  postgres:
+    image: "postgres:16.4-alpine3.20@sha256:d898b0b78a2627cb4ee63464a14efc9d296884f1b28c841b0ab7d7c42f1fffdf"
+    restart: always
+    environment:
+      POSTGRES_DB: speckle
+      POSTGRES_USER: speckle
+      POSTGRES_PASSWORD: speckle
+    volumes:
+      - postgres-data:/var/lib/postgresql/data/
+    healthcheck:
+      # the -U user has to match the POSTGRES_USER value
+      test: ["CMD-SHELL", "pg_isready -U speckle"]
+      interval: 5s
+      timeout: 5s
+      retries: 30
+
+  redis:
+    image: "redis:6.0-alpine"
+    restart: always
+    volumes:
+      - redis-data:/data
+    healthcheck:
+      test: ["CMD", "redis-cli", "--raw", "incr", "ping"]
+      interval: 5s
+      timeout: 5s
+      retries: 30
+
+  minio:
+    image: "minio/minio:RELEASE.2023-10-25T06-33-25Z"
+    command: server /data --console-address ":9001"
+    restart: always
+    volumes:
+      - minio-data:/data
+    healthcheck:
+      test:
+        [
+          "CMD-SHELL",
+          "curl -s -o /dev/null http://127.0.0.1:9000/minio/index.html",
+        ]
+      interval: 5s
+      timeout: 30s
+      retries: 30
+      start_period: 10s
+
+  speckle-server:
+    image: speckle/speckle-server:latest
+    restart: always
+    healthcheck:
+      test:
+        - CMD
+        - /nodejs/bin/node
+        - -e
+        - "try { require('node:http').request({headers: {'Content-Type': 'application/json'}, port:3000, hostname:'127.0.0.1', path:'/readiness', method: 'GET', timeout: 2000 }, (res) => { body = ''; res.on('data', (chunk) => {body += chunk;}); res.on('end', () => {process.exit(res.statusCode != 200 || body.toLowerCase().includes('error'));}); }).end(); } catch { process.exit(1); }"
+      interval: 10s
+      timeout: 10s
+      retries: 3
+      start_period: 90s
+    ports:
+      - "0.0.0.0:3000:3000"
+    depends_on:
+      postgres:
+        condition: service_healthy
+      redis:
+        condition: service_healthy
+      minio:
+        condition: service_healthy
+    environment:
+      # TODO: Change this to the URL of the speckle server, as accessed from the network
+      CANONICAL_URL: "http://127.0.0.1:8080"
+      SPECKLE_AUTOMATE_URL: "http://127.0.0.1:3030"
+      FRONTEND_ORIGIN: "http://127.0.0.1:8081"
+
+      # TODO: Change thvolumes:
+      REDIS_URL: "redis://redis"
+
+      S3_ENDPOINT: "http://minio:9000"
+      S3_ACCESS_KEY: "minioadmin"
+      S3_SECRET_KEY: "minioadmin"
+      S3_BUCKET: "speckle-server"
+      S3_CREATE_BUCKET: "true"
+
+      FILE_SIZE_LIMIT_MB: 100
+      MAX_PROJECT_MODELS_PER_PAGE: 500
+
+      # TODO: Change this to a unique secret for this server
+      SESSION_SECRET: "TODO:ReplaceWithLongString"
+
+      STRATEGY_LOCAL: "true"
+      DEBUG: "speckle:*"
+
+      POSTGRES_URL: "postgres"
+      POSTGRES_USER: "speckle"
+      POSTGRES_PASSWORD: "speckle"
+      POSTGRES_DB: "speckle"
+      ENABLE_MP: "false"
+
+networks:
+  default:
+    name: speckle-server
+
+volumes:
+  postgres-data:
+  redis-data:
+  minio-data:

example/many_children.py

@@ -0,0 +1,63 @@
+import os
+import random
+import string
+import time
+from pathlib import Path
+from typing import List
+
+from specklepy.api import operations
+from specklepy.objects import Base
+from specklepy.transports.sqlite import SQLiteTransport
+
+
+class Sub(Base):
+    bar: List[str]
+
+
+def random_string():
+    letters = string.ascii_lowercase
+    return "".join(random.choice(letters) for _ in range(10))
+
+
+BASE_PATH = SQLiteTransport.get_base_path("Speckle")
+
+
+def clean_db():
+    os.remove(Path(BASE_PATH, "Objects.db"))
+
+
+def one_pass(clean: bool, randomize: bool, child_count: int):
+    foo = Base()
+    for i in range(child_count):
+        stuff = random_string() if randomize else "stuff"
+        foo[f"@child_{i}"] = Sub(bar=["asdf", "bar", i, stuff])
+
+    if clean:
+        clean_db()
+    transport = SQLiteTransport()
+    start = time.time()
+    hash = operations.send(base=foo, transports=[transport])
+    send_time = time.time() - start
+
+    receive_start = time.time()
+    operations.receive(hash, transport)
+    receive_time = time.time() - receive_start
+    return send_time, receive_time
+
+
+if __name__ == "__main__":
+    sample_size = 4
+
+    test_permutations = [
+        (True, True),
+        (False, False),
+        (False, True),
+        (True, False),
+    ]
+    for clean, randomize in test_permutations:
+        print(f"CLEAN: {clean}, RANDOMIZE: {randomize}")
+        for child_count in [10, 100, 1000, 10000]:
+            print(f"\tCHILD COUNT: {child_count}")
+            for _ in range(sample_size):
+                send_time, receive_time = one_pass(clean, randomize, child_count)
+                print(f"\t\tSend: {send_time} Receive: {receive_time}")

example/send_receive.py

@@ -0,0 +1,15 @@
+from devtools import debug
+
+from specklepy.api import operations
+from specklepy.api.wrapper import StreamWrapper
+
+if __name__ == "__main__":
+    stream_url = "https://latest.speckle.dev/streams/7d051a6449"
+    wrapper = StreamWrapper(stream_url)
+
+    transport = wrapper.get_transport()
+
+    rec = operations.receive("98396753f8bf7fe1cb60c5193e9f9d86", transport)
+
+    # hash = operations.send(base=foo, transports=[transport], use_default_cache=False)
+    debug(rec)

example/stream_objects.py

@@ -0,0 +1,39 @@
+import random
+import string
+from typing import List
+
+from specklepy.api import operations
+from specklepy.api.wrapper import StreamWrapper
+from specklepy.objects import Base
+
+
+class Sub(Base):
+    bar: List[str]
+
+
+def random_string():
+    letters = string.ascii_lowercase
+    return "".join(random.choice(letters) for _ in range(10))
+
+
+def create_object(child_count: int) -> Base:
+    foo = Base()
+    for i in range(child_count):
+        stuff = random_string()
+        foo[f"@child_{i}"] = Sub(bar=["asdf", "bar", i, stuff])
+    return foo
+
+
+if __name__ == "__main__":
+    stream_url = "http://hyperion:3000/streams/2372b54c35"
+
+    child_count = 10
+    foo = create_object(child_count)
+
+    wrapper = StreamWrapper(stream_url)
+    transport = wrapper.get_transport()
+
+    hash = operations.send(base=foo, transports=[transport], use_default_cache=False)
+
+    rec = operations.receive(hash, transport)
+    print(rec)

example/units_none.py

@@ -0,0 +1,36 @@
+from devtools import debug
+
+from specklepy.api import operations
+from specklepy.objects_v2.geometry import Base
+from specklepy.objects_v2.units import Units
+
+dct = {
+    "id": "1234abcd",
+    "units": None,
+    "speckle_type": "Base",
+    "applicationId": None,
+    "totalChildrenCount": 0,
+}
+base = Base()
+for prop, value in dct.items():
+    base.__setattr__(prop, value)
+
+
+debug(base)
+debug(base.units)
+
+base.units = "m"
+debug(base.units)
+base.units = None
+
+debug(base.units)
+
+foo = operations.serialize(base)
+
+base.units = 10
+
+debug(base.units)
+debug(foo)
+
+base.units = Units.mm
+debug(base.units)

example/using_speckle_base.py

@@ -1,10 +1,11 @@
 """This is an example showcasing the usage of speckle `Base` class."""
 
 # the speckle.objects module exposes all speckle provided classes
-from specklepy.objects import Base
-from specklepy.api import operations
 from devtools import debug
 
+from specklepy.api import operations
+from specklepy.objects import Base
+
 
 class ExampleSub(Base):
     """
@@ -50,10 +51,10 @@ if __name__ == "__main__":
     )
     # support for dynamic attributes
     custom_sub.extra_extra = "what is this?"
-    debug(custom_sub.json())
+    debug(custom_sub)
 
     serialized = operations.serialize(custom_sub)
     deserialized = operations.deserialize(serialized)
     # the only difference should be between the two data is that the deserialized
     # instance id attribute is not None.
-    debug(deserialized.json())
+    debug(deserialized)

patch_version.py

@@ -1,31 +0,0 @@
-import re
-import sys
-
-
-def patch(tag):
-    print(f"Patching version: {tag}")
-
-    with open("pyproject.toml", "r") as f:
-        lines = f.readlines()
-
-        if "version" not in lines[2]:
-            raise Exception(f"Invalid pyproject.toml. Could not patch version.")
-
-        lines[2] = f'version = "{tag}"\n'
-        with open("pyproject.toml", "w") as file:
-            file.writelines(lines)
-
-
-def main():
-    if len(sys.argv) < 2:
-        return
-
-    tag = sys.argv[1]
-    if not re.match(r"[0-9]+(\.[0-9]+)*$", tag):
-        raise ValueError(f"Invalid tag provided: {tag}")
-
-    patch(tag)
-
-
-if __name__ == "__main__":
-    main()

pyproject.toml

@@ -1,50 +1,90 @@
-[tool.poetry]
+[project]
+dynamic = ["version"]
+# version = "3.0.0a1"
 name = "specklepy"
-version = "2.4.0"
 description = "The Python SDK for Speckle 2.0"
 readme = "README.md"
-authors = ["Speckle Systems <devops@speckle.systems>"]
+authors = [{ name = "Speckle Systems", email = "devops@speckle.systems" }]
-license = "Apache-2.0"
+license = { text = "Apache-2.0" }
-repository = "https://github.com/specklesystems/speckle-py"
+requires-python = ">=3.10.0, <4.0"
+dependencies = [
+    "appdirs>=1.4.4",
+    "attrs>=24.3.0",
+    "deprecated>=1.2.15",
+    "gql[requests,websockets]>=3.5.0",
+    "httpx>=0.28.1",
+    "pydantic>=2.10.5",
+    "pydantic-settings>=2.7.1",
+    "ujson>=5.10.0",
+]
+
+[dependency-groups]
+dev = [
+    "commitizen>=4.1.0",
+    "devtools>=0.12.2",
+    "hatch>=1.14.0",
+    "hatch-vcs>=0.4.0",
+    "pre-commit>=4.0.1",
+    "pytest>=8.3.4",
+    "pytest-asyncio>=0.25.2",
+    "pytest-cov>=6.0.0",
+    "pytest-ordering>=0.6",
+    "ruff>=0.9.2",
+    "types-deprecated>=1.2.15.20241117",
+    "types-requests>=2.32.0.20241016",
+    "types-ujson>=5.10.0.20240515",
+]
+
+[project.urls]
+repository = "https://github.com/specklesystems/specklepy"
 documentation = "https://speckle.guide/dev/py-examples.html"
 homepage = "https://speckle.systems/"
 
-
-[tool.poetry.dependencies]
-python = "^3.6.5"
-pydantic = "^1.8.2"
-appdirs = "^1.4.4"
-gql = {version = ">=3.0.0b1", extras = ["all"], allow-prereleases = true}
-ujson = "^4.3.0"
-
-[tool.poetry.dev-dependencies]
-black = "^20.8b1"
-isort = "^5.7.0"
-pytest = "^6.2.2"
-pytest-ordering = "^0.6"
-pytest-cov = "^3.0.0"
-
-
-[tool.black]
-exclude = '''
-/(
-    \.eggs
-  | \.git
-  | \.hg
-  | \.mypy_cache
-  | \.tox
-  | \.venv
-  | _build
-  | buck-out
-  | build
-  | dist
-)/
-'''
-include = '\.pyi?$'
-line-length = 88
-target-version = ["py36", "py37", "py38"]
-
-
 [build-system]
-requires = ["poetry-core>=1.0.0"]
+requires = ["hatchling", "hatch-vcs"]
-build-backend = "poetry.core.masonry.api"
+build-backend = "hatchling.build"
+
+[tool.hatch.version]
+source = "vcs"
+
+[tool.hatch.build.targets.wheel]
+only-include = ["src"]
+sources = ["src"]
+
+[tool.hatch.version.raw-options]
+local_scheme = "no-local-version"
+
+[tool.commitizen]
+name = "cz_conventional_commits"
+version = "2.9.2"
+tag_format = "$version"
+
+[tool.ruff]
+exclude = [".venv", "**/*.yml"]
+
+[tool.ruff.lint]
+select = [
+    # pycodestyle
+    "E",
+    # Pyflakes
+    "F",
+    # pyupgrade
+    "UP",
+    # flake8-bugbear
+    "B",
+    # flake8-simplify
+    "SIM",
+    # isort
+    "I",
+]
+ignore = ["UP006", "UP007", "UP035"]
+
+[[tool.uv.index]]
+name = "pypi"
+url = "https://pypi.org/simple/"
+publish-url = "https://upload.pypi.org/legacy/"
+
+[[tool.uv.index]]
+name = "test"
+url = "https://test.pypi.org/simple/"
+publish-url = "https://test.pypi.org/legacy/"

specklepy/api/client.py

@@ -1,147 +0,0 @@
-import re
-from gql.client import SyncClientSession
-from specklepy.logging.exceptions import SpeckleException
-from typing import Dict
-
-from specklepy.api import resources
-from specklepy.api.resources import (
-    branch,
-    commit,
-    stream,
-    object,
-    server,
-    user,
-    subscriptions,
-)
-from specklepy.api.models import ServerInfo
-from gql import Client, gql
-from gql.transport.requests import RequestsHTTPTransport
-from gql.transport.aiohttp import AIOHTTPTransport
-from gql.transport.websockets import WebsocketsTransport
-
-
-class SpeckleClient:
-    """
-    The `SpeckleClient` is your entry point for interacting with your Speckle Server's GraphQL API.
-    You'll need to have access to a server to use it, or you can use our public server `speckle.xyz`.
-
-    To authenticate the client, you'll need to have downloaded the [Speckle Manager](https://speckle.guide/#speckle-manager)
-    and added your account.
-
-    ```py
-    from specklepy.api.client import SpeckleClient
-    from specklepy.api.credentials import get_default_account
-
-    # initialise the client
-    client = SpeckleClient(host="speckle.xyz") # or whatever your host is
-    # client = SpeckleClient(host="localhost:3000", use_ssl=False) or use local server
-
-    # authenticate the client with a token (account has been added in Speckle Manager)
-    account = get_default_account()
-    client.authenticate(token=account.token)
-
-    # create a new stream. this returns the stream id
-    new_stream_id = client.stream.create(name="a shiny new stream")
-
-    # use that stream id to get the stream from the server
-    new_stream = client.stream.get(id=new_stream_id)
-    ```
-    """
-
-    DEFAULT_HOST = "speckle.xyz"
-    USE_SSL = True
-
-    def __init__(self, host: str = DEFAULT_HOST, use_ssl: bool = USE_SSL) -> None:
-        ws_protocol = "ws"
-        http_protocol = "http"
-
-        if use_ssl:
-            ws_protocol = "wss"
-            http_protocol = "https"
-
-        # sanitise host input by removing protocol and trailing slash
-        host = re.sub(r"((^\w+:|^)\/\/)|(\/$)", "", host)
-
-        self.url = f"{http_protocol}://{host}"
-        self.graphql = self.url + "/graphql"
-        self.ws_url = f"{ws_protocol}://{host}/graphql"
-        self.me = None
-
-        self.httpclient = Client(
-            transport=RequestsHTTPTransport(url=self.graphql, verify=True, retries=3)
-        )
-        self.wsclient = None
-
-        self._init_resources()
-
-        # Check compatibility with the server
-        try:
-            serverInfo = self.server.get()
-            if not isinstance(serverInfo, ServerInfo):
-                raise Exception("Couldn't get ServerInfo")
-        except Exception as ex:
-            raise SpeckleException(f"{self.url} is not a compatible Speckle Server", ex)
-
-    def __repr__(self):
-        return (
-            f"SpeckleClient( server: {self.url}, authenticated: {self.me is not None} )"
-        )
-
-    def authenticate(self, token: str) -> None:
-        """Authenticate the client using a personal access token
-        The token is saved in the client object and a synchronous GraphQL entrypoint is created
-
-        Arguments:
-            token {str} -- an api token
-        """
-        self.me = {"token": token}
-        headers = {
-            "Authorization": f"Bearer {self.me['token']}",
-            "Content-Type": "application/json",
-        }
-        httptransport = RequestsHTTPTransport(
-            url=self.graphql, headers=headers, verify=True, retries=3
-        )
-        wstransport = WebsocketsTransport(
-            url=self.ws_url,
-            init_payload={"Authorization": f"Bearer {self.me['token']}"},
-        )
-        self.httpclient = Client(transport=httptransport)
-        self.wsclient = Client(transport=wstransport)
-
-        self._init_resources()
-
-    def execute_query(self, query: str) -> Dict:
-        return self.httpclient.execute(query)
-
-    def _init_resources(self) -> None:
-        self.stream = stream.Resource(
-            me=self.me, basepath=self.url, client=self.httpclient
-        )
-        self.commit = commit.Resource(
-            me=self.me, basepath=self.url, client=self.httpclient
-        )
-        self.branch = branch.Resource(
-            me=self.me, basepath=self.url, client=self.httpclient
-        )
-        self.object = object.Resource(
-            me=self.me, basepath=self.url, client=self.httpclient
-        )
-        self.server = server.Resource(
-            me=self.me, basepath=self.url, client=self.httpclient
-        )
-        self.user = user.Resource(me=self.me, basepath=self.url, client=self.httpclient)
-        self.subscribe = subscriptions.Resource(
-            me=self.me,
-            basepath=self.ws_url,
-            client=self.wsclient,
-        )
-
-    def __getattr__(self, name):
-        try:
-            attr = getattr(resources, name)
-            return attr.Resource(me=self.me, basepath=self.url, client=self.httpclient)
-        except:
-            raise SpeckleException(
-                f"Method {name} is not supported by the SpeckleClient class"
-            )

specklepy/api/credentials.py

@@ -1,230 +0,0 @@
-import os
-from warnings import warn
-from pydantic import BaseModel
-from typing import List, Optional
-from urllib.parse import urlparse, unquote
-from specklepy.logging import metrics
-from specklepy.api.models import ServerInfo
-from specklepy.api.client import SpeckleClient
-from specklepy.transports.sqlite import SQLiteTransport
-from specklepy.transports.server.server import ServerTransport
-from specklepy.logging.exceptions import SpeckleException, SpeckleWarning
-
-
-class UserInfo(BaseModel):
-    name: str
-    email: str
-    company: Optional[str]
-    id: str
-
-
-class Account(BaseModel):
-    isDefault: bool = None
-    token: str
-    refreshToken: str = None
-    serverInfo: ServerInfo
-    userInfo: UserInfo
-    id: str = None
-
-    def __repr__(self) -> str:
-        return f"Account(email: {self.userInfo.email}, server: {self.serverInfo.url}, isDefault: {self.isDefault})"
-
-    def __str__(self) -> str:
-        return self.__repr__()
-
-
-def get_local_accounts(base_path: str = None) -> List[Account]:
-    """Gets all the accounts present in this environment
-
-    Arguments:
-        base_path {str} -- custom base path if you are not using the system default
-
-    Returns:
-        List[Account] -- list of all local accounts or an empty list if no accounts were found
-    """
-    metrics.track(metrics.ACCOUNT_LIST)
-    account_storage = SQLiteTransport(scope="Accounts", base_path=base_path)
-    json_path = os.path.join(account_storage._base_path, "Accounts")
-    os.makedirs(json_path, exist_ok=True)
-    json_acct_files = [file for file in os.listdir(json_path) if file.endswith(".json")]
-
-    accounts = []
-    res = account_storage.get_all_objects()
-    if res:
-        accounts.extend(Account.parse_raw(r[1]) for r in res)
-    if json_acct_files:
-        try:
-            accounts.extend(
-                Account.parse_file(os.path.join(json_path, json_file))
-                for json_file in json_acct_files
-            )
-        except Exception as ex:
-            raise SpeckleException(
-                "Invalid json accounts could not be read. Please fix or remove them.",
-                ex,
-            )
-
-    return accounts
-
-
-def get_default_account(base_path: str = None) -> Account:
-    """Gets this environment's default account if any. If there is no default, the first found will be returned and set as default.
-    Arguments:
-        base_path {str} -- custom base path if you are not using the system default
-
-    Returns:
-        Account -- the default account or None if no local accounts were found
-    """
-    metrics.track(metrics.ACCOUNT_DEFAULT)
-    accounts = get_local_accounts(base_path=base_path)
-    if not accounts:
-        return None
-
-    default = next((acc for acc in accounts if acc.isDefault), None)
-    if not default:
-        default = accounts[0]
-        default.isDefault = True
-
-    return default
-
-
-class StreamWrapper:
-    """
-    The `StreamWrapper` gives you some handy helpers to deal with urls and get authenticated clients and transports.
-
-    Construct a `StreamWrapper` with a stream, branch, commit, or object URL. The corresponding ids will be stored
-    in the wrapper. If you have local accounts on the machine, you can use the `get_account` and `get_client` methods
-    to get a local account for the server. You can also pass a token into `get_client` if you don't have a corresponding
-    local account for the server.
-
-    ```py
-    from specklepy.api.credentials import StreamWrapper
-
-    # provide any stream, branch, commit, object, or globals url
-    wrapper = StreamWrapper("https://speckle.xyz/streams/3073b96e86/commits/604bea8cc6")
-
-    # get an authenticated SpeckleClient if you have a local account for the server
-    client = wrapper.get_client()
-
-    # get an authenticated ServerTransport if you have a local account for the server
-    transport = wrapper.get_transport()
-    ```
-    """
-
-    stream_url: str = None
-    use_ssl: bool = True
-    host: str = None
-    stream_id: str = None
-    commit_id: str = None
-    object_id: str = None
-    branch_name: str = None
-    client: SpeckleClient = None
-    account: Account = None
-
-    def __repr__(self):
-        return f"StreamWrapper( server: {self.host}, stream_id: {self.stream_id}, type: {self.type} )"
-
-    def __str__(self) -> str:
-        return self.__repr__()
-
-    @property
-    def type(self) -> str:
-        if self.object_id:
-            return "object"
-        elif self.commit_id:
-            return "commit"
-        elif self.branch_name:
-            return "branch"
-        else:
-            return "stream" if self.stream_id else "invalid"
-
-    def __init__(self, url: str) -> None:
-        metrics.track("streamwrapper")
-        self.stream_url = url
-        parsed = urlparse(url)
-        self.host = parsed.netloc
-        self.use_ssl = parsed.scheme == "https"
-        segments = parsed.path.strip("/").split("/", 3)
-
-        if not segments or len(segments) < 2:
-            raise SpeckleException(
-                f"Cannot parse {url} into a stream wrapper class - invalid URL provided."
-            )
-
-        while segments:
-            segment = segments.pop(0)
-            if segments and segment.lower() == "streams":
-                self.stream_id = segments.pop(0)
-            elif segments and segment.lower() == "commits":
-                self.commit_id = segments.pop(0)
-            elif segments and segment.lower() == "branches":
-                self.branch_name = unquote(segments.pop(0))
-            elif segments and segment.lower() == "objects":
-                self.object_id = segments.pop(0)
-            elif segment.lower() == "globals":
-                self.branch_name = "globals"
-                if segments:
-                    self.commit_id = segments.pop(0)
-            else:
-                raise SpeckleException(
-                    f"Cannot parse {url} into a stream wrapper class - invalid URL provided."
-                )
-
-        if not self.stream_id:
-            raise SpeckleException(
-                f"Cannot parse {url} into a stream wrapper class - no stream id found."
-            )
-
-    def get_account(self) -> Account:
-        """
-        Gets an account object for this server from the local accounts db (added via Speckle Manager or a json file)
-        """
-        if self.account:
-            return self.account
-
-        self.account = next(
-            (a for a in get_local_accounts() if self.host in a.serverInfo.url),
-            None,
-        )
-
-        return self.account
-
-    def get_client(self, token: str = None) -> SpeckleClient:
-        """
-        Gets an authenticated client for this server. You may provide a token if there aren't any local accounts on this
-        machine. If no account is found and no token is provided, an unauthenticated client is returned.
-
-        Arguments:
-            token {str} -- optional token if no local account is available (defaults to None)
-
-        Returns:
-            SpeckleClient -- authenticated with a corresponding local account or the provided token
-        """
-        if self.client and token is None:
-            return self.client
-
-        if not self.account:
-            self.get_account()
-
-        if not self.client:
-            self.client = SpeckleClient(host=self.host, use_ssl=self.use_ssl)
-
-        if self.account is None and token is None:
-            warn(f"No local account found for server {self.host}", SpeckleWarning)
-            return self.client
-
-        self.client.authenticate(self.account.token if self.account else token)
-
-        return self.client
-
-    def get_transport(self, token: str = None) -> ServerTransport:
-        """
-        Gets a server transport for this stream using an authenticated client. If there is no local account for this
-        server and the client was not authenticated with a token, this will throw an exception.
-
-        Returns:
-            ServerTransport -- constructed for this stream with a pre-authenticated client
-        """
-        if not self.client or not self.client.me:
-            self.get_client(token)
-        return ServerTransport(self.stream_id, self.client)

specklepy/api/models.py

@@ -1,119 +0,0 @@
-# generated by datamodel-codegen:
-#   filename:  stream_schema.json
-#   timestamp: 2020-11-17T14:33:13+00:00
-
-from datetime import datetime
-from typing import Any, Dict, List, Optional
-
-
-from pydantic import BaseModel
-
-
-class Collaborator(BaseModel):
-    id: Optional[str]
-    name: Optional[str]
-    role: Optional[str]
-    avatar: Optional[str]
-
-
-class Commit(BaseModel):
-    id: Optional[str]
-    message: Optional[str]
-    authorName: Optional[str]
-    authorId: Optional[str]
-    authorAvatar: Optional[str]
-    branchName: Optional[str]
-    createdAt: Optional[str]
-    sourceApplication: Optional[str]
-    referencedObject: Optional[str]
-    totalChildrenCount: Optional[int]
-    parents: Optional[List[str]]
-
-    def __repr__(self) -> str:
-        return f"Commit( id: {self.id}, message: {self.message}, referencedObject: {self.referencedObject}, authorName: {self.authorName}, branchName: {self.branchName}, createdAt: {self.createdAt} )"
-
-    def __str__(self) -> str:
-        return self.__repr__()
-
-
-class Commits(BaseModel):
-    totalCount: Optional[int]
-    cursor: Optional[Any]
-    items: List[Commit] = []
-
-
-class Object(BaseModel):
-    id: Optional[str]
-    speckleType: Optional[str]
-    applicationId: Optional[str]
-    totalChildrenCount: Optional[int]
-    createdAt: Optional[str]
-
-
-class Branch(BaseModel):
-    id: Optional[str]
-    name: Optional[str]
-    description: Optional[str]
-    commits: Optional[Commits]
-
-
-class Branches(BaseModel):
-    totalCount: Optional[int]
-    cursor: Optional[datetime]
-    items: List[Branch] = []
-
-
-class Stream(BaseModel):
-    id: Optional[str]
-    name: Optional[str]
-    description: Optional[str]
-    isPublic: Optional[bool]
-    createdAt: Optional[str]
-    updatedAt: Optional[str]
-    collaborators: List[Collaborator] = []
-    branches: Optional[Branches]
-    commit: Optional[Commit]
-    object: Optional[Object]
-
-    def __repr__(self):
-        return f"Stream( id: {self.id}, name: {self.name}, description: {self.description}, isPublic: {self.isPublic})"
-
-    def __str__(self) -> str:
-        return self.__repr__()
-
-
-class Streams(BaseModel):
-    totalCount: Optional[int]
-    cursor: Optional[datetime]
-    items: List[Stream] = []
-
-
-class User(BaseModel):
-    id: Optional[str]
-    email: Optional[str]
-    name: Optional[str]
-    bio: Optional[str]
-    company: Optional[str]
-    avatar: Optional[str]
-    verified: Optional[bool]
-    role: Optional[str]
-    streams: Optional[Streams]
-
-    def __repr__(self):
-        return f"User( id: {self.id}, name: {self.name}, email: {self.email}, company: {self.company} )"
-
-    def __str__(self) -> str:
-        return self.__repr__()
-
-
-class ServerInfo(BaseModel):
-    name: Optional[str]
-    company: Optional[str]
-    url: Optional[str]
-    description: Optional[str]
-    adminContact: Optional[str]
-    canonicalUrl: Optional[str]
-    roles: Optional[List[dict]]
-    scopes: Optional[List[dict]]
-    authStrategies: Optional[List[dict]]
-    version: Optional[str]

specklepy/api/resource.py

@@ -1,81 +0,0 @@
-from specklepy.transports.sqlite import SQLiteTransport
-from typing import Dict, List
-from gql.client import Client
-from gql.gql import gql
-from gql.transport.exceptions import TransportQueryError
-from specklepy.logging.exceptions import GraphQLException, SpeckleException
-from specklepy.serialization.base_object_serializer import BaseObjectSerializer
-
-
-class ResourceBase(object):
-    def __init__(
-        self,
-        me: Dict,
-        basepath: str,
-        client: Client,
-        name: str,
-        methods: list,
-    ) -> None:
-        self.me = me
-        self.basepath = basepath
-        self.client = client
-        self.name = name
-        self.methods = methods
-        self.schema = None
-
-    def _step_into_response(self, response: dict, return_type: str or List):
-        """Step into the dict to get the relevant data"""
-        if return_type is None:
-            return response
-        elif isinstance(return_type, str):
-            return response[return_type]
-        elif isinstance(return_type, List):
-            for key in return_type:
-                response = response[key]
-            return response
-
-    def _parse_response(self, response: dict or list, schema=None):
-        """Try to create a class instance from the response"""
-        if isinstance(response, list):
-            return [self._parse_response(response=r, schema=schema) for r in response]
-        if schema:
-            return schema.parse_obj(response)
-        elif self.schema:
-            try:
-                return self.schema.parse_obj(response)
-            except:
-                s = BaseObjectSerializer(read_transport=SQLiteTransport())
-                return s.recompose_base(response)
-        else:
-            return response
-
-    def make_request(
-        self,
-        query: gql,
-        params: Dict = None,
-        return_type: str or List = None,
-        schema=None,
-        parse_response: bool = True,
-    ) -> Dict or GraphQLException:
-        """Executes the GraphQL query"""
-        try:
-            response = self.client.execute(query, variable_values=params)
-        except Exception as e:
-            if isinstance(e, TransportQueryError):
-                return GraphQLException(
-                    message=f"Failed to execute the GraphQL {self.name} request. Errors: {e.errors}",
-                    errors=e.errors,
-                    data=e.data,
-                )
-            else:
-                return SpeckleException(
-                    message=f"Failed to execute the GraphQL {self.name} request. Inner exception: {e}",
-                    exception=e,
-                )
-
-        response = self._step_into_response(response=response, return_type=return_type)
-
-        if parse_response:
-            return self._parse_response(response=response, schema=schema)
-        else:
-            return response

specklepy/api/resources/__init__.py

@@ -1,13 +0,0 @@
-from pathlib import Path
-import sys
-import inspect
-import pkgutil
-from importlib import import_module
-
-
-for (_, name, _) in pkgutil.iter_modules(__path__):
-
-    imported_module = import_module("." + name, package=__name__)
-
-    if hasattr(imported_module, "Resource"):
-        setattr(sys.modules[__name__], name, imported_module)

specklepy/api/resources/branch.py

@@ -1,212 +0,0 @@
-from specklepy.api.resources import stream
-from typing import List, Optional
-from gql import gql
-from pydantic.main import BaseModel
-from specklepy.api.resource import ResourceBase
-from specklepy.api.models import Branch
-
-NAME = "branch"
-METHODS = ["create"]
-
-
-class Resource(ResourceBase):
-    """API Access class for branches"""
-
-    def __init__(self, me, basepath, client) -> None:
-        super().__init__(
-            me=me, basepath=basepath, client=client, name=NAME, methods=METHODS
-        )
-        self.schema = Branch
-
-    def create(
-        self, stream_id: str, name: str, description: str = "No description provided"
-    ) -> str:
-        """Create a new branch on this stream
-
-        Arguments:
-            name {str} -- the name of the new branch
-            description {str} -- a short description of the branch
-
-        Returns:
-            id {str} -- the newly created branch's id
-        """
-
-        query = gql(
-            """
-            mutation BranchCreate($branch: BranchCreateInput!) {
-              branchCreate(branch: $branch)
-            }
-          """
-        )
-        params = {
-            "branch": {
-                "streamId": stream_id,
-                "name": name,
-                "description": description,
-            }
-        }
-
-        return self.make_request(
-            query=query, params=params, return_type="branchCreate", parse_response=False
-        )
-
-    def get(self, stream_id: str, name: str, commits_limit: int = 10):
-        """Get a branch by name from a stream
-
-        Arguments:
-            stream_id {str} -- the id of the stream to get the branch from
-            name {str} -- the name of the branch to get
-            commits_limit {int} -- maximum number of commits to get
-
-        Returns:
-            Branch -- the fetched branch with its latest commits
-        """
-
-        query = gql(
-            """
-            query BranchGet($stream_id: String!, $name: String!, $commits_limit: Int!) {
-                stream(id: $stream_id) {
-                        branch(name: $name) {
-                          id,
-                          name,
-                          description,
-                          commits (limit: $commits_limit) {
-                            totalCount,
-                            cursor,
-                            items {
-                              id,
-                              referencedObject,
-                              sourceApplication,
-                              totalChildrenCount,
-                              message,
-                              authorName,
-                              authorId,
-                              branchName,
-                              parents,
-                              createdAt
-                            }
-                        }
-                    }                      
-                }
-            }
-            """
-        )
-
-        params = {"stream_id": stream_id, "name": name, "commits_limit": commits_limit}
-
-        return self.make_request(
-            query=query, params=params, return_type=["stream", "branch"]
-        )
-
-    def list(self, stream_id: str, branches_limit: int = 10, commits_limit: int = 10):
-        """Get a list of branches from a given stream
-
-        Arguments:
-            stream_id {str} -- the id of the stream to get the branches from
-            branches_limit {int} -- maximum number of branches to get
-            commits_limit {int} -- maximum number of commits to get
-
-        Returns:
-            List[Branch] -- the branches on the stream
-        """
-        query = gql(
-            """
-            query BranchesGet($stream_id: String!, $branches_limit: Int!, $commits_limit: Int!) {
-                stream(id: $stream_id) {
-                    branches(limit: $branches_limit) {
-                        items {
-                            id
-                            name
-                            description
-                            commits(limit: $commits_limit) {
-                                totalCount
-                                items{
-                                    id
-                                    message
-                                    referencedObject
-                                    sourceApplication
-                                    parents
-                                    authorId
-                                    authorName
-                                    branchName
-                                    createdAt
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            """
-        )
-
-        params = {
-            "stream_id": stream_id,
-            "branches_limit": branches_limit,
-            "commits_limit": commits_limit,
-        }
-
-        return self.make_request(
-            query=query, params=params, return_type=["stream", "branches", "items"]
-        )
-
-    def update(
-        self, stream_id: str, branch_id: str, name: str = None, description: str = None
-    ):
-        """Update a branch
-
-        Arguments:
-            stream_id {str} -- the id of the stream containing the branch to update
-            branch_id {str} -- the id of the branch to update
-            name {str} -- optional: the updated branch name
-            description {str} -- optional: the updated branch description
-
-        Returns:
-            bool -- True if update is successfull
-        """
-        query = gql(
-            """
-            mutation  BranchUpdate($branch: BranchUpdateInput!) {
-                branchUpdate(branch: $branch)
-                }
-            """
-        )
-        params = {
-            "branch": {
-                "streamId": stream_id,
-                "id": branch_id,
-            }
-        }
-
-        if name:
-            params["branch"]["name"] = name
-        if description:
-            params["branch"]["description"] = description
-
-        return self.make_request(
-            query=query, params=params, return_type="branchUpdate", parse_response=False
-        )
-
-    def delete(self, stream_id: str, branch_id: str):
-        """Delete a branch
-
-        Arguments:
-            stream_id {str} -- the id of the stream containing the branch to delete
-            branch_id {str} -- the branch to delete
-
-        Returns:
-            bool -- True if deletion is successful
-        """
-
-        query = gql(
-            """
-            mutation BranchDelete($branch: BranchDeleteInput!) {
-                branchDelete(branch: $branch)
-            }
-            """
-        )
-
-        params = {"branch": {"streamId": stream_id, "id": branch_id}}
-
-        return self.make_request(
-            query=query, params=params, return_type="branchDelete", parse_response=False
-        )

specklepy/api/resources/commit.py

@@ -1,225 +0,0 @@
-from typing import Optional, List
-from gql import gql
-from specklepy.api.resource import ResourceBase
-from specklepy.api.models import Commit
-
-
-NAME = "commit"
-METHODS = []
-
-
-class Resource(ResourceBase):
-    """API Access class for commits"""
-
-    def __init__(self, me, basepath, client) -> None:
-        super().__init__(
-            me=me, basepath=basepath, client=client, name=NAME, methods=METHODS
-        )
-        self.schema = Commit
-
-    def get(self, stream_id: str, commit_id: str) -> Commit:
-        """
-        Gets a commit given a stream and the commit id
-
-        Arguments:
-            stream_id {str} -- the stream where we can find the commit
-            commit_id {str} -- the id of the commit you want to get
-
-        Returns:
-            Commit -- the retrieved commit object
-        """
-        query = gql(
-            """
-            query Commit($stream_id: String!, $commit_id: String!) {
-                stream(id: $stream_id) {
-                    commit(id: $commit_id) {
-                        id
-                        message
-                        referencedObject
-                        authorId
-                        authorName
-                        authorAvatar
-                        branchName
-                        createdAt
-                        sourceApplication
-                        totalChildrenCount
-                        parents
-                    }
-                }
-            }
-            """
-        )
-        params = {"stream_id": stream_id, "commit_id": commit_id}
-
-        return self.make_request(
-            query=query, params=params, return_type=["stream", "commit"]
-        )
-
-    def list(self, stream_id: str, limit: int = 10) -> List[Commit]:
-        """
-        Get a list of commits on a given stream
-
-        Arguments:
-            stream_id {str} -- the stream where the commits are
-            limit {int} -- the maximum number of commits to fetch (default = 10)
-
-        Returns:
-            List[Commit] -- a list of the most recent commit objects
-        """
-        query = gql(
-            """
-            query Commits($stream_id: String!, $limit: Int!) {
-                stream(id: $stream_id) {
-                    commits(limit: $limit) {
-                        items {
-                            id
-                            message
-                            referencedObject
-                            authorName
-                            authorId
-                            authorName
-                            authorAvatar
-                            branchName
-                            createdAt
-                            sourceApplication
-                            totalChildrenCount
-                            parents
-                        }
-                    }
-                }
-            }
-            """
-        )
-        params = {"stream_id": stream_id, "limit": limit}
-
-        return self.make_request(
-            query=query, params=params, return_type=["stream", "commits", "items"]
-        )
-
-    def create(
-        self,
-        stream_id: str,
-        object_id: str,
-        branch_name: str = "main",
-        message: str = "",
-        source_application: str = "python",
-        parents: List[str] = None,
-    ) -> str:
-        """
-        Creates a commit on a branch
-
-        Arguments:
-            stream_id {str} -- the stream you want to commit to
-            object_id {str} -- the hash of your commit object
-            branch_name {str} -- the name of the branch to commit to (defaults to "main")
-            message {str} -- optional: a message to give more information about the commit
-            source_application{str} -- optional: the application from which the commit was created (defaults to "python")
-            parents {List[str]} -- optional: the id of the parent commits
-
-        Returns:
-            str -- the id of the created commit
-        """
-        query = gql(
-            """
-            mutation CommitCreate ($commit: CommitCreateInput!){ commitCreate(commit: $commit)}
-            """
-        )
-        params = {
-            "commit": {
-                "streamId": stream_id,
-                "branchName": branch_name,
-                "objectId": object_id,
-                "message": message,
-                "sourceApplication": source_application,
-            }
-        }
-        if parents:
-            params["commit"]["parents"] = parents
-
-        return self.make_request(
-            query=query, params=params, return_type="commitCreate", parse_response=False
-        )
-
-    def update(self, stream_id: str, commit_id: str, message: str) -> bool:
-        """
-        Update a commit
-
-        Arguments:
-            stream_id {str} -- the id of the stream that contains the commit you'd like to update
-            commit_id {str} -- the id of the commit you'd like to update
-            message {str} -- the updated commit message
-
-        Returns:
-            bool -- True if the operation succeeded
-        """
-        query = gql(
-            """
-            mutation CommitUpdate($commit: CommitUpdateInput!){ commitUpdate(commit: $commit)}
-            """
-        )
-        params = {
-            "commit": {"streamId": stream_id, "id": commit_id, "message": message}
-        }
-
-        return self.make_request(
-            query=query, params=params, return_type="commitUpdate", parse_response=False
-        )
-
-    def delete(self, stream_id: str, commit_id: str) -> bool:
-        """
-        Delete a commit
-
-        Arguments:
-            stream_id {str} -- the id of the stream that contains the commit you'd like to delete
-            commit_id {str} -- the id of the commit you'd like to delete
-
-        Returns:
-            bool -- True if the operation succeeded
-        """
-        query = gql(
-            """
-            mutation CommitDelete($commit: CommitDeleteInput!){ commitDelete(commit: $commit)}
-            """
-        )
-        params = {"commit": {"streamId": stream_id, "id": commit_id}}
-
-        return self.make_request(
-            query=query, params=params, return_type="commitDelete", parse_response=False
-        )
-
-    def received(
-        self,
-        stream_id: str,
-        commit_id: str,
-        source_application: str = "python",
-        message: Optional[str] = None,
-    ) -> bool:
-        """
-        Mark a commit object a received by the source application.
-        """
-        query = gql(
-            """
-            mutation CommitReceive($receivedInput:CommitReceivedInput!){
-                commitReceive(input:$receivedInput)
-            }
-            """
-        )
-        params = {
-            "receivedInput": {
-                "sourceApplication": source_application,
-                "streamId": stream_id,
-                "commitId": commit_id,
-                "message": "message",
-            }
-        }
-
-        try:
-            return self.make_request(
-                query=query,
-                params=params,
-                return_type="commitReceive",
-                parse_response=False,
-            )
-        except Exception as ex:
-            print(ex.with_traceback)
-            return False

specklepy/api/resources/object.py

@@ -1,80 +0,0 @@
-from typing import Dict, List
-from gql import gql
-from graphql.language import parser
-from specklepy.api.resource import ResourceBase
-from specklepy.objects.base import Base
-
-NAME = "object"
-METHODS = []
-
-
-class Resource(ResourceBase):
-    """API Access class for objects"""
-
-    def __init__(self, me, basepath, client) -> None:
-        super().__init__(
-            me=me, basepath=basepath, client=client, name=NAME, methods=METHODS
-        )
-        self.schema = Base
-
-    def get(self, stream_id: str, object_id: str) -> Base:
-        """
-        Get a stream object
-
-        Arguments:
-            stream_id {str} -- the id of the stream for the object
-            object_id {str} -- the hash of the object you want to get
-
-        Returns:
-            Base -- the returned Base object
-        """
-        query = gql(
-            """
-            query Object($stream_id: String!, $object_id: String!) {
-              stream(id: $stream_id) {
-                id
-                name
-                object(id: $object_id) {
-                  id
-                  speckleType
-                  applicationId
-                  createdAt
-                  totalChildrenCount
-                  data
-                }
-              }
-            }
-          """
-        )
-        params = {"stream_id": stream_id, "object_id": object_id}
-
-        return self.make_request(
-            query=query, params=params, return_type=["stream", "object", "data"]
-        )
-
-    def create(self, stream_id: str, objects: List[Dict]) -> str:
-        """
-        Not advised - generally, you want to use `operations.send()`.
-
-        Create a new object on a stream. To send a base object, you can prepare it by running it through the
-        `BaseObjectSerializer.traverse_base()` function to get a valid (serialisable) object to send.
-
-        NOTE: this does not create a commit - you can create one with `SpeckleClient.commit.create`. Dynamic fields will be located in the 'data' dict of the received `Base` object
-
-        Arguments:
-            stream_id {str} -- the id of the stream you want to send the object to
-            objects {List[Dict]} -- a list of base dictionary objects (NOTE: must be json serialisable)
-
-        Returns:
-            str -- the id of the object
-        """
-        query = gql(
-            """
-          mutation ObjectCreate($object_input: ObjectCreateInput!) { objectCreate(objectInput: $object_input) }
-          """
-        )
-        params = {"object_input": {"streamId": stream_id, "objects": objects}}
-
-        return self.make_request(
-            query=query, params=params, return_type="objectCreate", parse_response=False
-        )

specklepy/api/resources/stream.py

@@ -1,364 +0,0 @@
-from gql import gql
-from typing import Dict, List, Optional
-from specklepy.logging import metrics
-from specklepy.api.models import Stream
-from specklepy.api.resource import ResourceBase
-
-
-NAME = "stream"
-METHODS = [
-    "list",
-    "create",
-    "get",
-    "update",
-    "delete",
-    "search",
-]
-
-
-class Resource(ResourceBase):
-    """API Access class for streams"""
-
-    def __init__(self, me, basepath, client) -> None:
-        super().__init__(
-            me=me, basepath=basepath, client=client, name=NAME, methods=METHODS
-        )
-
-        self.schema = Stream
-
-    def get(self, id: str, branch_limit: int = 10, commit_limit: int = 10) -> Stream:
-        """Get the specified stream from the server
-
-        Arguments:
-            id {str} -- the stream id
-            branch_limit {int} -- the maximum number of branches to return
-            commit_limit {int} -- the maximum number of commits to return
-
-        Returns:
-            Stream -- the retrieved stream
-        """
-        metrics.track(metrics.STREAM_GET)
-        query = gql(
-            """
-            query Stream($id: String!, $branch_limit: Int!, $commit_limit: Int!) {
-              stream(id: $id) {
-                id
-                name
-                description
-                isPublic
-                createdAt
-                updatedAt
-                collaborators {
-                  id
-                  name
-                  role
-                  avatar
-                }
-                branches(limit: $branch_limit) {
-                  totalCount
-                  cursor
-                  items {
-                    id
-                    name
-                    description
-                    commits(limit: $commit_limit) {
-                      totalCount
-                      cursor
-                      items {
-                        id
-                        referencedObject
-                        message
-                        authorName
-                        authorId
-                        createdAt
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          """
-        )
-
-        params = {"id": id, "branch_limit": branch_limit, "commit_limit": commit_limit}
-
-        return self.make_request(query=query, params=params, return_type="stream")
-
-    def list(self, stream_limit: int = 10) -> List[Stream]:
-        """Get a list of the user's streams
-
-        Arguments:
-            stream_limit {int} -- The maximum number of streams to return
-
-        Returns:
-            List[Stream] -- A list of Stream objects
-        """
-        metrics.track(metrics.STREAM_LIST)
-        query = gql(
-            """
-            query User($stream_limit: Int!) {
-              user {
-                id
-                email
-                name
-                bio
-                company
-                avatar
-                verified
-                profiles
-                role
-                streams(limit: $stream_limit) {
-                  totalCount
-                  cursor
-                  items {
-                    id
-                    name
-                    description
-                    isPublic
-                    createdAt
-                    updatedAt
-                    collaborators {
-                      id
-                      name
-                      role
-                    }
-                  }
-                }
-              }
-            }
-          """
-        )
-
-        params = {"stream_limit": stream_limit}
-
-        return self.make_request(
-            query=query, params=params, return_type=["user", "streams", "items"]
-        )
-
-    def create(
-        self,
-        name: str = "Anonymous Python Stream",
-        description: str = "No description provided",
-        is_public: bool = True,
-    ) -> str:
-        """Create a new stream
-
-        Arguments:
-            name {str} -- the name of the string
-            description {str} -- a short description of the stream
-            is_public {bool} -- whether or not the stream can be viewed by anyone with the id
-
-        Returns:
-            id {str} -- the id of the newly created stream
-        """
-        metrics.track(metrics.STREAM_CREATE)
-        query = gql(
-            """
-            mutation StreamCreate($stream: StreamCreateInput!) {
-              streamCreate(stream: $stream)
-            }
-        """
-        )
-
-        params = {
-            "stream": {"name": name, "description": description, "isPublic": is_public}
-        }
-
-        return self.make_request(
-            query=query, params=params, return_type="streamCreate", parse_response=False
-        )
-
-    def update(
-        self, id: str, name: str = None, description: str = None, is_public: bool = None
-    ) -> bool:
-        """Update an existing stream
-
-        Arguments:
-            id {str} -- the id of the stream to be updated
-            name {str} -- the name of the string
-            description {str} -- a short description of the stream
-            is_public {bool} -- whether or not the stream can be viewed by anyone with the id
-
-        Returns:
-            bool -- whether the stream update was successful
-        """
-        metrics.track(metrics.STREAM_UPDATE)
-        query = gql(
-            """
-            mutation StreamUpdate($stream: StreamUpdateInput!) {
-              streamUpdate(stream: $stream)
-            }
-        """
-        )
-
-        params = {
-            "id": id,
-            "name": name,
-            "description": description,
-            "isPublic": is_public,
-        }
-        # remove None values so graphql doesn't cry
-        params = {"stream": {k: v for k, v in params.items() if v is not None}}
-
-        return self.make_request(
-            query=query, params=params, return_type="streamUpdate", parse_response=False
-        )
-
-    def delete(self, id: str) -> bool:
-        """Delete a stream given its id
-
-        Arguments:
-            id {str} -- the id of the stream to delete
-
-        Returns:
-            bool -- whether the deletion was successful
-        """
-        metrics.track(metrics.STREAM_DELETE)
-        query = gql(
-            """
-            mutation StreamDelete($id: String!) {
-              streamDelete(id: $id)
-            }
-        """
-        )
-
-        params = {"id": id}
-
-        return self.make_request(
-            query=query, params=params, return_type="streamDelete", parse_response=False
-        )
-
-    def search(
-        self,
-        search_query: str,
-        limit: int = 25,
-        branch_limit: int = 10,
-        commit_limit: int = 10,
-    ):
-        """Search for streams by name, description, or id
-
-        Arguments:
-            search_query {str} -- a string to search for
-            limit {int} -- the maximum number of results to return
-            branch_limit {int} -- the maximum number of branches to return
-            commit_limit {int} -- the maximum number of commits to return
-
-        Returns:
-            List[Stream] -- a list of Streams that match the search query
-        """
-        metrics.track(metrics.STREAM_SEARCH)
-        query = gql(
-            """
-            query StreamSearch($search_query: String!,$limit: Int!, $branch_limit:Int!, $commit_limit:Int!) {
-              streams(query: $search_query, limit: $limit) {
-                items {
-                  id
-                  name
-                  description
-                  isPublic
-                  createdAt
-                  updatedAt
-                  collaborators {
-                    id
-                    name
-                    role
-                    avatar
-                  }
-                  branches(limit: $branch_limit) {
-                    totalCount
-                    cursor
-                    items {
-                      id
-                      name
-                      description
-                      commits(limit: $commit_limit) {
-                        totalCount
-                        cursor
-                        items {
-                          id
-                          referencedObject
-                          message
-                          authorName
-                          authorId
-                          createdAt
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          """
-        )
-
-        params = {
-            "search_query": search_query,
-            "limit": limit,
-            "branch_limit": branch_limit,
-            "commit_limit": commit_limit,
-        }
-
-        return self.make_request(
-            query=query, params=params, return_type=["streams", "items"]
-        )
-
-    def grant_permission(self, stream_id: str, user_id: str, role: str):
-        """Grant permissions to a user on a given stream
-
-        Arguments:
-            stream_id {str} -- the id of the stream to grant permissions to
-            user_id {str} -- the id of the user to grant permissions for
-            role {str} -- the role to grant the user
-
-        Returns:
-            bool -- True if the operation was successful
-        """
-        query = gql(
-            """
-            mutation StreamGrantPermission($permission_params: StreamGrantPermissionInput !) {
-                streamGrantPermission(permissionParams: $permission_params)
-            }
-            """
-        )
-
-        params = {
-            "permission_params": {
-                "streamId": stream_id,
-                "userId": user_id,
-                "role": role,
-            }
-        }
-
-        return self.make_request(
-            query=query,
-            params=params,
-            return_type="streamGrantPermission",
-            parse_response=False,
-        )
-
-    def revoke_permission(self, stream_id: str, user_id: str):
-        """Revoke permissions from a user on a given stream
-
-        Arguments:
-            stream_id {str} -- the id of the stream to revoke permissions from
-            user_id {str} -- the id of the user to revoke permissions from
-
-        Returns:
-            bool -- True if the operation was successful
-        """
-        query = gql(
-            """
-            mutation StreamRevokePermission($permission_params: StreamRevokePermissionInput !) {
-                streamRevokePermission(permissionParams: $permission_params)
-            }
-            """
-        )
-
-        params = {"permission_params": {"streamId": stream_id, "userId": user_id}}
-
-        return self.make_request(
-            query=query,
-            params=params,
-            return_type="streamRevokePermission",
-            parse_response=False,
-        )

specklepy/api/resources/subscriptions.py

@@ -1,125 +0,0 @@
-from typing import Callable, Dict, List, Optional, Any
-from functools import wraps
-from gql import gql
-from specklepy.api.resource import ResourceBase
-from specklepy.api.resources.stream import Stream
-from specklepy.logging.exceptions import GraphQLException, SpeckleException
-
-NAME = "subscribe"
-METHODS = [
-    "stream_added",
-    "stream_updated",
-    "stream_removed",
-]
-
-
-def check_wsclient(function):
-    @wraps(function)
-    async def check_wsclient_wrapper(self, *args, **kwargs):
-        if self.client is None:
-            raise SpeckleException(
-                "You must authenticate before you can subscribe to events"
-            )
-        else:
-            return await function(self, *args, **kwargs)
-
-    return check_wsclient_wrapper
-
-
-class Resource(ResourceBase):
-    """API Access class for subscriptions"""
-
-    def __init__(self, me, basepath, client) -> None:
-        super().__init__(
-            me=me, basepath=basepath, client=client, name=NAME, methods=METHODS
-        )
-
-    @check_wsclient
-    async def stream_added(self, callback: Callable = None):
-        """Subscribes to new stream added event for your profile. Use this to display an up-to-date list of streams.
-
-        Arguments:
-            callback {Callable[Stream]} -- a function that takes the updated stream as an argument and executes each time a stream is added
-
-        Returns:
-            Stream -- the update stream
-        """
-        query = gql(
-            """
-            subscription { userStreamAdded }
-            """
-        )
-        return await self.subscribe(
-            query=query, callback=callback, return_type="userStreamAdded", schema=Stream
-        )
-
-    @check_wsclient
-    async def stream_updated(self, id: str, callback: Callable = None):
-        """Subscribes to stream updated event. Use this in clients/components that pertain only to this stream.
-
-        Arguments:
-            id {str} -- the stream id of the stream to subscribe to
-            callback {Callable[Stream]} -- a function that takes the updated stream as an argument and executes each time the stream is updated
-
-        Returns:
-            Stream -- the update stream
-        """
-        query = gql(
-            """
-            subscription Update($id: String!) { streamUpdated(streamId: $id) }
-            """
-        )
-        params = {"id": id}
-
-        return await self.subscribe(
-            query=query,
-            params=params,
-            callback=callback,
-            return_type="streamUpdated",
-            schema=Stream,
-        )
-
-    @check_wsclient
-    async def stream_removed(self, callback: Callable = None):
-        """Subscribes to stream removed event for your profile. Use this to display an up-to-date list of streams for your profile. NOTE: If someone revokes your permissions on a stream, this subscription will be triggered with an extra value of revokedBy in the payload.
-
-        Arguments:
-            callback {Callable[Dict]} -- a function that takes the returned dict as an argument and executes each time a stream is removed
-
-        Returns:
-            dict -- dict containing 'id' of stream removed and optionally 'revokedBy'
-        """
-        query = gql(
-            """
-            subscription { userStreamRemoved }
-            """
-        )
-
-        return await self.subscribe(
-            query=query,
-            callback=callback,
-            return_type="userStreamRemoved",
-            parse_response=False,
-        )
-
-    @check_wsclient
-    async def subscribe(
-        self,
-        query: gql,
-        params: Dict = None,
-        callback: Callable = None,
-        return_type: str or List = None,
-        schema=None,
-        parse_response: bool = True,
-    ):
-        # if self.client.transport.websocket is None:
-        #     TODO: add multiple subs to the same ws connection
-        async with self.client as session:
-            async for res in session.subscribe(query, variable_values=params):
-                res = self._step_into_response(response=res, return_type=return_type)
-                if parse_response:
-                    res = self._parse_response(response=res, schema=schema)
-                if callback is not None:
-                    callback(res)
-                else:
-                    return res

specklepy/api/resources/user.py

@@ -1,120 +0,0 @@
-from specklepy.logging.exceptions import SpeckleException
-from typing import List, Optional
-from gql import gql
-from pydantic.main import BaseModel
-from specklepy.api.resource import ResourceBase
-from specklepy.api.models import User
-
-NAME = "user"
-METHODS = ["get"]
-
-
-class Resource(ResourceBase):
-    """API Access class for users"""
-
-    def __init__(self, me, basepath, client) -> None:
-        super().__init__(
-            me=me, basepath=basepath, client=client, name=NAME, methods=METHODS
-        )
-        self.schema = User
-
-    def get(self, id: str = None) -> User:
-        """Gets the profile of a user. If no id argument is provided, will return the current authenticated user's profile (as extracted from the authorization header).
-
-        Arguments:
-            id {str} -- the user id
-
-        Returns:
-            User -- the retrieved user
-        """
-        query = gql(
-            """
-            query User($id: String) {
-                user(id: $id) {
-                    id
-                    email
-                    name
-                    bio
-                    company
-                    avatar
-                    verified
-                    profiles
-                    role
-                }
-            }
-          """
-        )
-
-        params = {"id": id}
-
-        return self.make_request(query=query, params=params, return_type="user")
-
-    def search(self, search_query: str, limit: int = 25) -> List[User]:
-        """Searches for user by name or email. The search query must be at least 3 characters long
-
-        Arguments:
-            search_query {str} -- a string to search for
-            limit {int} -- the maximum number of results to return
-        Returns:
-            List[User] -- a list of User objects that match the search query
-        """
-        if len(search_query) < 3:
-            return SpeckleException(
-                message="User search query must be at least 3 characters"
-            )
-
-        query = gql(
-            """
-            query UserSearch($search_query: String!, $limit: Int!) {
-                userSearch(query: $search_query, limit: $limit) {
-                    items {
-                        id
-                        name
-                        bio
-                        company
-                        avatar
-                        verified
-                    }
-                }
-            }
-          """
-        )
-        params = {"search_query": search_query, "limit": limit}
-
-        return self.make_request(
-            query=query, params=params, return_type=["userSearch", "items"]
-        )
-
-    def update(
-        self, name: str = None, company: str = None, bio: str = None, avatar: str = None
-    ):
-        """Updates your user profile. All arguments are optional.
-
-        Arguments:
-            name {str} -- your name
-            company {str} -- the company you may or may not work for
-            bio {str} -- tell us about yourself
-            avatar {str} -- a nice photo of yourself
-
-        Returns:
-            bool -- True if your profile was updated successfully
-        """
-        query = gql(
-            """
-            mutation UserUpdate($user: UserUpdateInput!) {
-                userUpdate(user: $user)
-            }
-            """
-        )
-        params = {"name": name, "company": company, "bio": bio, "avatar": avatar}
-
-        params = {"user": {k: v for k, v in params.items() if v is not None}}
-
-        if not params["user"]:
-            return SpeckleException(
-                message="You must provide at least one field to update your user profile"
-            )
-
-        return self.make_request(
-            query=query, params=params, return_type="userUpdate", parse_response=False
-        )

specklepy/api/speckle2schema.graphql

@@ -1,640 +0,0 @@
-
-      
-scalar DateTime
-
-scalar EmailAddress
-
-scalar BigInt
-
-scalar JSONObject
-
-
-      directive @hasScope(scope: String!) on FIELD_DEFINITION
-      directive @hasRole(role: String!) on FIELD_DEFINITION
-
-      type Query {
-      """
-      Stare into the void.
-      """
-        _: String
-      }
-      type Mutation{
-      """
-      The void stares back.
-      """
-      _: String
-      }
-      type Subscription{
-        """
-        It's lonely in the void.
-        """
-        _: String
-      },extend type Query {
-  """
-  Gets a specific app from the server.
-  """
-  app( id: String! ): ServerApp
-
-  """
-  Returns all the publicly available apps on this server.
-  """
-  apps: [ServerAppListItem]
-}
-
-type ServerApp {
-  id: String!
-  secret: String!
-  name: String!
-  description: String
-  termsAndConditionsLink: String
-  logo: String
-  public: Boolean
-  trustByDefault: Boolean
-  author: AppAuthor
-  createdAt: DateTime!
-  redirectUrl: String!
-  scopes: [Scope]!
-}
-
-type ServerAppListItem {
-  id: String!
-  name: String!
-  description: String
-  termsAndConditionsLink: String
-  logo: String
-  author: AppAuthor
-}
-
-type AppAuthor {
-  name: String
-  id: String
-}
-
-extend type User {
-  """
-  Returns the apps you have authorized.
-  """
-  authorizedApps: [ServerAppListItem]
-    @hasRole(role: "server:user")
-    @hasScope(scope: "apps:read")
-
-  """
-  Returns the apps you have created.
-  """
-  createdApps: [ServerAppListItem]
-    @hasRole(role: "server:user")
-    @hasScope(scope: "apps:read")
-}
-
-extend type Mutation {
-  """
-  Register a new third party application.
-  """
-  appCreate(app: AppCreateInput!): String!
-    @hasRole(role: "server:user")
-    @hasScope(scope: "apps:write")
-
-  """
-  Update an existing third party application. **Note: This will invalidate all existing tokens, refresh tokens and access codes and will require existing users to re-authorize it.**
-  """
-  appUpdate(app: AppUpdateInput!): Boolean!
-    @hasRole(role: "server:user")
-    @hasScope(scope: "apps:write")
-
-  """
-  Deletes a thirty party application.
-  """
-  appDelete(appId: String!): Boolean!
-    @hasRole(role: "server:user")
-    @hasScope(scope: "apps:write")
-
-  """
-  Revokes (de-authorizes) an application that you have previously authorized.
-  """
-  appRevokeAccess(appId: String!): Boolean
-    @hasRole(role: "server:user")
-    @hasScope(scope: "apps:write")
-
-}
-
-input AppCreateInput {
-  name: String!
-  description: String!
-  termsAndConditionsLink: String
-  logo: String
-  public: Boolean
-  redirectUrl: String!
-  scopes: [String]!
-}
-
-input AppUpdateInput {
-  id: String!
-  name: String!
-  description: String!
-  termsAndConditionsLink: String
-  logo: String
-  public: Boolean
-  redirectUrl: String!
-  scopes: [String]!
-}
-,extend type ServerInfo {
-  """
-  The authentication strategies available on this server.
-  """
-  authStrategies: [AuthStrategy]
-}
-
-type AuthStrategy {
-  id: String!,
-  name: String!,
-  icon: String!,
-  url: String!,
-  color: String
-}
-,extend type User{
-  """
-  Returns a list of your personal api tokens.
-  """
-  apiTokens: [ApiToken]
-    @hasRole(role: "server:user")
-    @hasScope(scope: "tokens:read")
-}
-
-type ApiToken {
-  id: String!
-  name: String!
-  lastChars: String!
-  scopes: [String]!
-  createdAt: DateTime! #date
-  lifespan: BigInt!
-  lastUsed: String! #date
-}
-
-input ApiTokenCreateInput {
-  scopes: [String!]!,
-  name: String!,
-  lifespan: BigInt
-}
-
-extend type Mutation {
-  """
-  Creates an personal api token.
-  """
-  apiTokenCreate(token: ApiTokenCreateInput!):String!
-    @hasRole(role: "server:user")
-    @hasScope(scope: "tokens:write")
-  """
-  Revokes (deletes) an personal api token.
-  """
-  apiTokenRevoke(token: String!):Boolean!
-    @hasRole(role: "server:user")
-    @hasScope(scope: "tokens:write")
-}
-,extend type Stream {
-  commits(limit: Int! = 25, cursor: String): CommitCollection
-  commit(id: String!): Commit
-  branches(limit: Int! = 25, cursor: String): BranchCollection
-  branch(name: String!): Branch
-}
-
-extend type User {
-  commits(limit: Int! = 25, cursor: String): CommitCollectionUser
-}
-
-type Branch {
-  id: String!
-  name: String!
-  author: User!
-  description: String
-  commits(limit: Int! = 25, cursor: String): CommitCollection
-}
-
-type Commit {
-  id: String!
-  referencedObject: String!
-  message: String
-  authorName: String
-  authorId: String
-  createdAt: DateTime
-}
-
-type CommitCollectionUserNode {
-  id: String!
-  referencedObject: String!
-  message: String
-  streamId: String
-  streamName: String
-  createdAt: DateTime
-}
-
-type BranchCollection {
-  totalCount: Int!
-  cursor: String
-  items: [Branch]
-}
-
-type CommitCollection {
-  totalCount: Int!
-  cursor: String
-  items: [Commit]
-}
-
-type CommitCollectionUser {
-  totalCount: Int!
-  cursor: String
-  items: [CommitCollectionUserNode]
-}
-
-extend type Mutation {
-  branchCreate(branch: BranchCreateInput!): String!
-    @hasRole(role: "server:user")
-    @hasScope(scope: "streams:write")
-  branchUpdate(branch: BranchUpdateInput!): Boolean!
-    @hasRole(role: "server:user")
-    @hasScope(scope: "streams:write")
-  branchDelete(branch: BranchDeleteInput!): Boolean!
-    @hasRole(role: "server:user")
-    @hasScope(scope: "streams:write")
-
-  commitCreate(commit: CommitCreateInput!): String!
-    @hasRole(role: "server:user")
-    @hasScope(scope: "streams:write")
-  commitUpdate(commit: CommitUpdateInput!): Boolean!
-    @hasRole(role: "server:user")
-    @hasScope(scope: "streams:write")
-  commitDelete(commit: CommitDeleteInput!): Boolean!
-    @hasRole(role: "server:user")
-    @hasScope(scope: "streams:write")
-}
-
-extend type Subscription {
-  # TODO: auth for these subscriptions
-  """
-  Subscribe to branch created event
-  """
-  branchCreated(streamId: String!): JSONObject
-    @hasRole(role: "server:user")
-    @hasScope(scope: "streams:read")
-  """
-  Subscribe to branch updated event.
-  """
-  branchUpdated(streamId: String!, branchId: String): JSONObject
-    @hasRole(role: "server:user")
-    @hasScope(scope: "streams:read")
-  """
-  Subscribe to branch deleted event
-  """
-  branchDeleted(streamId: String!): JSONObject
-    @hasRole(role: "server:user")
-    @hasScope(scope: "streams:read")
-
-  """
-  Subscribe to commit created event
-  """
-  commitCreated(streamId: String!): JSONObject
-    @hasRole(role: "server:user")
-    @hasScope(scope: "streams:read")
-  """
-  Subscribe to commit updated event.
-  """
-  commitUpdated(streamId: String!, commitId: String): JSONObject
-    @hasRole(role: "server:user")
-    @hasScope(scope: "streams:read")
-  """
-  Subscribe to commit deleted event
-  """
-  commitDeleted(streamId: String!): JSONObject
-    @hasRole(role: "server:user")
-    @hasScope(scope: "streams:read")
-}
-
-input BranchCreateInput {
-  streamId: String!
-  name: String!
-  description: String
-}
-
-input BranchUpdateInput {
-  streamId: String!
-  id: String!
-  name: String
-  description: String
-}
-
-input BranchDeleteInput {
-  streamId: String!
-  id: String!
-}
-
-input CommitCreateInput {
-  streamId: String!
-  branchName: String!
-  objectId: String!
-  message: String
-  previousCommitIds: [String]
-}
-
-input CommitUpdateInput {
-  streamId: String!
-  id: String!
-  message: String!
-}
-
-input CommitDeleteInput {
-  streamId: String!
-  id: String!
-}
-,extend type Stream {
-  object( id: String! ): Object
-}
-
-type Object {
-  id: String! 
-  speckleType: String!
-  applicationId: String
-  createdAt: DateTime
-  totalChildrenCount: Int
-  """
-  The full object, with all its props & other things. **NOTE:** If you're requesting objects for the purpose of recreating & displaying, you probably only want to request this specific field.
-  """
-  data: JSONObject
-  """
-  Get any objects that this object references. In the case of commits, this will give you a commit's constituent objects.
-  **NOTE**: Providing any of the two last arguments ( `query`, `orderBy` ) will trigger a different code branch that executes a much more expensive SQL query. It is not recommended to do so for basic clients that are interested in purely getting all the objects of a given commit.
-  """
-  children(
-    limit: Int! = 100, 
-    depth: Int! = 50, 
-    select: [String], 
-    cursor: String, 
-    query: [JSONObject!],
-    orderBy: JSONObject  ): ObjectCollection!
-}
-
-type ObjectCollection {
-  totalCount: Int!
-  cursor: String
-  objects: [Object]!
-}
-
-extend type Mutation {
-  objectCreate( objectInput: ObjectCreateInput! ): [String]!
-}
-
-input ObjectCreateInput {
-  """
-  The stream against which these objects will be created. 
-  """
-  streamId: String!
-  """
-  The objects you want to create.
-  """
-  objects: [JSONObject]!
-},extend type Query {
-  serverInfo: ServerInfo!
-}
-
-"""
-Information about this server.
-"""
-type ServerInfo {
-  name: String!
-  company: String
-  description: String
-  adminContact: String
-  canonicalUrl: String
-  termsOfService: String
-  roles: [Role]!
-  scopes: [Scope]!
-}
-
-"""
-Available roles.
-"""
-type Role {
-  name: String!
-  description: String!
-  resourceTarget: String!
-}
-
-"""
-Available scopes.
-"""
-type Scope {
-  name: String!
-  description: String!
-}
-
-extend type Mutation {
-  serverInfoUpdate(info: ServerInfoUpdateInput!): Boolean
-    @hasRole(role: "server:admin")
-    @hasScope(scope: "server:setup")
-}
-
-input ServerInfoUpdateInput {
-  name: String!
-  company: String
-  description: String
-  adminContact: String
-  termsOfService: String
-}
-,extend type Query {
-  """
-  Returns a specific stream.
-  """
-  stream( id: String! ): Stream
-
-  """
-  All the streams of the current user, pass in the `query` parameter to seach by name, description or ID.
-  """
-  streams( query: String, limit: Int = 25, cursor: String ): StreamCollection
-    @hasScope(scope: "streams:read")
-}
-
-type Stream {
-  id: String!
-  name: String!
-  description: String
-  isPublic: Boolean!
-  createdAt: DateTime!
-  updatedAt: DateTime!
-  collaborators: [ StreamCollaborator ]!
-}
-
-extend type User {
-  """
-  All the streams that a user has access to.
-  """
-  streams( limit: Int! = 25, cursor: String ): StreamCollection
-}
-
-type StreamCollaborator {
-  id: String!
-  name: String!
-  role: String!
-  company: String
-  avatar: String
-}
-
-type StreamCollection {
-  totalCount: Int!
-  cursor: String
-  items: [ Stream ]
-}
-
-
-extend type Mutation {
-  """
-  Creates a new stream.
-  """
-  streamCreate( stream: StreamCreateInput! ): String
-    @hasRole(role: "server:user")
-    @hasScope(scope: "streams:write")
-  """
-  Updates an existing stream.
-  """
-  streamUpdate( stream: StreamUpdateInput! ): Boolean!
-    @hasRole(role: "server:user")
-    @hasScope(scope: "streams:write")
-  """
-  Deletes an existing stream.
-  """
-  streamDelete( id: String! ): Boolean!
-    @hasRole(role: "server:user")
-    @hasScope(scope: "streams:write")
-  """
-  Grants permissions to a user on a given stream.
-  """
-  streamGrantPermission( permissionParams: StreamGrantPermissionInput! ): Boolean
-    @hasRole(role: "server:user")
-    @hasScope(scope: "streams:write")
-  """
-  Revokes the permissions of a user on a given stream.
-  """
-  streamRevokePermission( permissionParams: StreamRevokePermissionInput! ): Boolean
-    @hasRole(role: "server:user")
-    @hasScope(scope: "streams:write")
-}
-
-extend type Subscription {
-
-  #
-  # User bound subscriptions that operate on the stream collection of an user
-  # Example relevant view/usecase: updating the list of streams for a user.
-  #
-
-  """
-  Subscribes to new stream added event for your profile. Use this to display an up-to-date list of streams.
-  **NOTE**: If someone shares a stream with you, this subscription will be triggered with an extra value of `sharedBy` in the payload.
-  """
-  userStreamAdded: JSONObject
-    @hasRole(role: "server:user")
-    @hasScope(scope: "profile:read")
-
-  """
-  Subscribes to stream removed event for your profile. Use this to display an up-to-date list of streams for your profile.
-  **NOTE**: If someone revokes your permissions on a stream, this subscription will be triggered with an extra value of `revokedBy` in the payload.
-  """
-  userStreamRemoved: JSONObject
-    @hasRole(role: "server:user")
-    @hasScope(scope: "profile:read")
-
-  #
-  # Stream bound subscriptions that operate on the stream itself.
-  # Example relevant view/usecase: a single stream connector, or view, or component in a web app
-  #
-
-  """
-  Subscribes to stream updated event. Use this in clients/components that pertain only to this stream.
-  """
-  streamUpdated( streamId: String ): JSONObject
-    @hasRole(role: "server:user")
-    @hasScope(scope: "streams:read")
-
-  """
-  Subscribes to stream deleted event. Use this in clients/components that pertain only to this stream.
-  """
-  streamDeleted( streamId: String ): JSONObject
-    @hasRole(role: "server:user")
-    @hasScope(scope: "streams:read")
-
-}
-
-input StreamCreateInput {
-  name: String
-  description: String
-  isPublic: Boolean
-}
-
-input StreamUpdateInput {
-  id: String!
-  name: String
-  description: String
-  isPublic: Boolean
-}
-
-input StreamGrantPermissionInput {
-  streamId: String!,
-  userId: String!,
-  role: String!
-}
-
-input StreamRevokePermissionInput {
-  streamId: String!,
-  userId: String!
-}
-,extend type Query {
-  """
-  Gets the profile of a user. If no id argument is provided, will return the current authenticated user's profile (as extracted from the authorization header).
-  """
-  user(id: String): User
-  userSearch(
-    query: String!
-    limit: Int! = 25
-    cursor: String
-  ): UserSearchResultCollection
-  userPwdStrength(pwd: String!): JSONObject
-}
-
-"""
-Base user type.
-"""
-type User {
-  id: String!
-  suuid: String
-  email: String
-  name: String
-  bio: String
-  company: String
-  avatar: String
-  verified: Boolean
-  profiles: JSONObject
-  role: String
-}
-
-type UserSearchResultCollection {
-  cursor: String
-  items: [UserSearchResult]
-}
-
-type UserSearchResult {
-  id: String!
-  name: String
-  bio: String
-  company: String
-  avatar: String
-  verified: Boolean
-}
-
-extend type Mutation {
-  """
-  Edits a user's profile.
-  """
-  userUpdate(user: UserUpdateInput!): Boolean!
-}
-
-input UserUpdateInput {
-  name: String
-  company: String
-  bio: String
-}

specklepy/logging/exceptions.py

@@ -1,35 +0,0 @@
-from typing import Any, List
-
-
-class SpeckleException(Exception):
-    def __init__(self, message: str, exception: Exception = None) -> None:
-        self.message = message
-        self.exception = exception
-
-    def __str__(self) -> str:
-        return f"SpeckleException: {self.message}"
-
-
-class SerializationException(SpeckleException):
-    def __init__(self, message: str, object: Any, exception: Exception = None) -> None:
-        super().__init__(message=message)
-        self.object = object
-        self.unhandled_type = type(object)
-
-    def __str__(self) -> str:
-        return f"SpeckleException: Could not serialize object of type {self.unhandled_type}"
-
-
-class GraphQLException(SpeckleException):
-    def __init__(self, message: str, errors: List, data=None) -> None:
-        super().__init__(message=message)
-        self.errors = errors
-        self.data = data
-
-    def __str__(self) -> str:
-        return f"GraphQLException: {self.message}"
-
-
-class SpeckleWarning(Warning):
-    def __init__(self, *args: object) -> None:
-        super().__init__(*args)

specklepy/logging/metrics.py

@@ -1,125 +0,0 @@
-import os
-import queue
-import logging
-import requests
-import threading
-from requests.sessions import session
-from specklepy.transports.sqlite import SQLiteTransport
-
-"""
-Anonymous telemetry to help us understand how to make a better Speckle.
-This really helps us to deliver a better open source project and product!
-"""
-TRACK = True
-HOST_APP = "python"
-
-LOG = logging.getLogger(__name__)
-METRICS_TRACKER = None
-
-# actions
-RECEIVE = "receive"
-SEND = "send"
-STREAM_CREATE = "stream/create"
-STREAM_GET = "stream/get"
-STREAM_UPDATE = "stream/update"
-STREAM_DELETE = "stream/delete"
-STREAM_DETAILS = "stream/details"
-STREAM_LIST = "stream/list"
-STREAM_VIEW = "stream/view"
-STREAM_SEARCH = "stream/search"
-
-ACCOUNT_DEFAULT = "account/default"
-ACCOUNT_DETAILS = "account/details"
-ACCOUNT_LIST = "account/list"
-
-SERIALIZE = "serialization/serialize"
-DESERIALIZE = "serialization/deserialize"
-
-
-def disable():
-    global TRACK
-    TRACK = False
-
-
-def set_host_app(host_app: str):
-    global HOST_APP
-    HOST_APP = host_app
-
-
-def track(action: str):
-    if not TRACK:
-        return
-    try:
-        global METRICS_TRACKER
-        if not METRICS_TRACKER:
-            METRICS_TRACKER = MetricsTracker()
-
-        page_params = {
-            "rec": 1,
-            "idsite": METRICS_TRACKER.site_id,
-            "uid": METRICS_TRACKER.suuid,
-            "action_name": action,
-            "url": f"http://connectors/{HOST_APP}/{action}",
-            "urlref": f"http://connectors/{HOST_APP}/{action}",
-            "_cvar": {"1": ["hostApplication", HOST_APP]},
-        }
-
-        event_params = {
-            "rec": 1,
-            "idsite": METRICS_TRACKER.site_id,
-            "uid": MetricsTracker.suuid,
-            "_cvar": {"1": ["hostApplication", HOST_APP]},
-            "e_c": HOST_APP,
-            "e_a": action,
-        }
-
-        METRICS_TRACKER.queue.put_nowait([event_params, page_params])
-    except Exception as ex:
-        # wrapping this whole thing in a try except as we never want a failure here to annoy users!
-        LOG.error("Error queueing metrics request: " + str(ex))
-
-
-class Singleton(type):
-    _instances = {}
-
-    def __call__(cls, *args, **kwargs):
-        if cls not in cls._instances:
-            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
-        return cls._instances[cls]
-
-
-class MetricsTracker(metaclass=Singleton):
-    matomo_url = "https://speckle.matomo.cloud/matomo.php"
-    site_id = 2
-    host_app = "python"
-    suuid = None
-    sending_thread = None
-    queue = queue.Queue(1000)
-
-    def __init__(self) -> None:
-        self.sending_thread = threading.Thread(
-            target=self._send_tracking_requests, daemon=True
-        )
-        self.set_suuid()
-        self.sending_thread.start()
-
-    def set_suuid(self):
-        try:
-            file_path = os.path.join(SQLiteTransport.get_base_path("Speckle"), "suuid")
-            with open(file_path, "r") as file:
-                self.suuid = file.read()
-        except:
-            self.suuid = "unknown-suuid"
-
-    def _send_tracking_requests(self):
-        session = requests.Session()
-        while True:
-            params = self.queue.get()
-
-            try:
-                session.post(self.matomo_url, params=params[0])
-                session.post(self.matomo_url, params=params[1])
-            except Exception as ex:
-                LOG.error("Error sending metrics request: " + str(ex))
-
-            self.queue.task_done()

specklepy/objects/__init__.py

@@ -1,5 +0,0 @@
-"""Builtin Speckle object kit."""
-
-from specklepy.objects.base import Base
-
-__all__ = ["Base"]

specklepy/objects/encoding.py

@@ -1,136 +0,0 @@
-from enum import Enum
-from typing import Any, Callable, List, Type
-
-from specklepy.logging.exceptions import SpeckleException
-from specklepy.objects.base import Base
-
-
-class CurveTypeEncoding(int, Enum):
-    Arc = 0
-    Circle = 1
-    Curve = 2
-    Ellipse = 3
-    Line = 4
-    Polyline = 5
-    Polycurve = 6
-
-    @property
-    def object_class(self) -> Type:
-        from . import geometry
-
-        if self == self.Arc:
-            return geometry.Arc
-        elif self == self.Circle:
-            return geometry.Circle
-        elif self == self.Curve:
-            return geometry.Curve
-        elif self == self.Ellipse:
-            return geometry.Ellipse
-        elif self == self.Line:
-            return geometry.Line
-        elif self == self.Polyline:
-            return geometry.Polyline
-        elif self == self.Polycurve:
-            return geometry.Polycurve
-        raise SpeckleException(
-            f"No corresponding object class for CurveTypeEncoding: {self}"
-        )
-
-
-def curve_from_list(args: List[float]):
-    curve_type = CurveTypeEncoding(args[0])
-    return curve_type.object_class.from_list(args)
-
-
-class ObjectArray:
-    def __init__(self) -> None:
-        self.data = []
-
-    @classmethod
-    def from_objects(cls, objects: List[Base]) -> "ObjectArray":
-        data_list = cls()
-        if not objects:
-            return data_list
-
-        speckle_type = objects[0].speckle_type
-
-        for obj in objects:
-            if speckle_type != obj.speckle_type:
-                raise SpeckleException(
-                    "All objects in chunk should have the same speckle_type. "
-                    f"Found {speckle_type} and {obj.speckle_type}"
-                )
-            data_list.encode_object(object=obj)
-
-        return data_list
-
-    @staticmethod
-    def decode_data(
-        data: List[Any], decoder: Callable[[List[Any]], Base]
-    ) -> List[Base]:
-        bases = []
-        if not data:
-            return bases
-
-        index = 0
-        while index < len(data):
-            item_length = data[index]
-            item_start = index + 1
-            item_end = item_start + item_length
-            item_data = data[item_start:item_end]
-            index = item_end
-            # TODO: investigate what's going on w this fail
-            try:
-                decoded_data = decoder(item_data)
-                bases.append(decoded_data)
-            except ValueError:
-                continue
-        return bases
-
-    def decode(self, decoder: Callable[[List[Any]], Any]):
-        return self.decode_data(data=self.data, decoder=decoder)
-
-    def encode_object(self, object: Base):
-        encoded = object.to_list()
-        encoded.insert(0, len(encoded))
-        self.data.extend(encoded)
-
-
-class CurveArray(ObjectArray):
-    @classmethod
-    def from_curve(cls, curve: Base) -> "CurveArray":
-        crv_array = cls()
-        crv_array.data = curve.to_list()
-        return crv_array
-
-    @classmethod
-    def from_curves(cls, curves: List[Base]) -> "CurveArray":
-        data = []
-        for curve in curves:
-            curve_list = curve.to_list()
-            curve_list.insert(0, len(curve_list))
-            data.extend(curve_list)
-        crv_array = cls()
-        crv_array.data = data
-        return crv_array
-
-    @staticmethod
-    def curve_from_list(args: List[float]) -> Base:
-        curve_type = CurveTypeEncoding(args[0])
-        return curve_type.object_class.from_list(args)
-
-    @property
-    def type(self) -> CurveTypeEncoding:
-        return CurveTypeEncoding(self.data[0])
-
-    def to_curve(self) -> Base:
-        return self.type.object_class.from_list(self.data)
-
-    @classmethod
-    def _curve_decoder(cls, data: List[float]) -> Base:
-        crv_array = cls()
-        crv_array.data = data
-        return crv_array.to_curve()
-
-    def to_curves(self) -> List[Base]:
-        return self.decode(decoder=self._curve_decoder)

specklepy/objects/fakemesh.py

@@ -1,43 +0,0 @@
-from specklepy.objects.geometry import Point
-from typing import List
-
-from .base import Base
-
-CHUNKABLE_PROPS = {
-    "vertices": 100,
-    "faces": 100,
-    "colors": 100,
-    "textureCoordinates": 100,
-    "test_bases": 10,
-}
-
-DETACHABLE = {"detach_this", "origin", "detached_list"}
-
-
-class FakeGeo(Base, chunkable={"dots": 50}, detachable={"pointslist"}):
-    pointslist: List[Base] = None
-    dots: List[int] = None
-
-
-class FakeMesh(FakeGeo, chunkable=CHUNKABLE_PROPS, detachable=DETACHABLE):
-    vertices: List[float] = None
-    faces: List[int] = None
-    colors: List[int] = None
-    textureCoordinates: List[float] = None
-    test_bases: List[Base] = None
-    detach_this: Base = None
-    detached_list: List[Base] = None
-    _origin: Point = None
-
-    # def __init__(self, **kwargs) -> None:
-    #     super(FakeMesh, self).__init__(**kwargs)
-    #     self.add_chunkable_attrs(**CHUNKABLE_PROPS)
-    #     self.add_detachable_attrs(DETACHABLE)
-
-    @property
-    def origin(self):
-        return self._origin
-
-    @origin.setter
-    def origin(self, value: Point):
-        self._origin = value

specklepy/objects/geometry.py

@@ -1,735 +0,0 @@
-from enum import Enum
-from typing import Any, List, Optional
-
-from .base import Base
-from .encoding import CurveArray, CurveTypeEncoding, ObjectArray
-from .units import get_encoding_from_units, get_units_from_encoding
-
-GEOMETRY = "Objects.Geometry."
-
-
-class Interval(Base, speckle_type="Objects.Primitive.Interval"):
-    start: float = 0.0
-    end: float = 0.0
-
-    def length(self):
-        return abs(self.start - self.end)
-
-    @classmethod
-    def from_list(cls, args: List[Any]) -> "Interval":
-        return cls(start=args[0], end=args[1])
-
-    def to_list(self) -> List[Any]:
-        return [self.start, self.end]
-
-
-class Point(Base, speckle_type=GEOMETRY + "Point"):
-    x: float = 0.0
-    y: float = 0.0
-    z: float = 0.0
-
-    def __repr__(self) -> str:
-        return f"{self.__class__.__name__}(x: {self.x}, y: {self.y}, z: {self.z}, id: {self.id}, speckle_type: {self.speckle_type})"
-
-    @classmethod
-    def from_list(cls, args: List[float]) -> "Point":
-        return cls(x=args[0], y=args[1], z=args[2])
-
-    def to_list(self) -> List[Any]:
-        return [self.x, self.y, self.z]
-
-    @classmethod
-    def from_coords(cls, x: float = 0.0, y: float = 0.0, z: float = 0.0):
-        pt = Point()
-        pt.x, pt.y, pt.z = x, y, z
-        return pt
-
-
-class Vector(Point, speckle_type=GEOMETRY + "Vector"):
-    pass
-
-
-class ControlPoint(Point, speckle_type=GEOMETRY + "ControlPoint"):
-    weight: float = None
-
-
-class Plane(Base, speckle_type=GEOMETRY + "Plane"):
-    origin: Point = Point()
-    normal: Vector = Vector()
-    xdir: Vector = Vector()
-    ydir: Vector = Vector()
-
-    @classmethod
-    def from_list(cls, args: List[Any]) -> "Plane":
-        return cls(
-            origin=Point.from_list(args[0:3]),
-            normal=Vector.from_list(args[3:6]),
-            xdir=Vector.from_list(args[6:9]),
-            ydir=Vector.from_list(args[9:12]),
-        )
-
-    def to_list(self) -> List[Any]:
-        encoded = []
-        encoded.extend(self.origin.to_list())
-        encoded.extend(self.normal.to_list())
-        encoded.extend(self.xdir.to_list())
-        encoded.extend(self.ydir.to_list())
-        return encoded
-
-
-class Box(Base, speckle_type=GEOMETRY + "Box"):
-    basePlane: Plane = Plane()
-    ySize: Interval = Interval()
-    zSize: Interval = Interval()
-    xSize: Interval = Interval()
-    area: float = None
-    volume: float = None
-
-
-class Line(Base, speckle_type=GEOMETRY + "Line"):
-    start: Point = Point()
-    end: Point = None
-    domain: Interval = None
-    bbox: Box = None
-    length: float = None
-
-    @classmethod
-    def from_list(cls, args: List[Any]) -> "Line":
-        return cls(
-            start=Point.from_list(args[0:3]),
-            end=Point.from_list(args[3:6]),
-            domain=Interval.from_list(args[6:9]),
-        )
-
-    def to_list(self) -> List[Any]:
-        encoded = []
-        encoded.extend(self.start.to_list())
-        encoded.extend(self.end.to_list())
-        encoded.extend(self.domain.to_list())
-        return encoded
-
-
-class Arc(Base, speckle_type=GEOMETRY + "Arc"):
-    radius: float = None
-    startAngle: float = None
-    endAngle: float = None
-    angleRadians: float = None
-    plane: Plane = None
-    domain: Interval = None
-    startPoint: Point = None
-    midPoint: Point = None
-    endPoint: Point = None
-    bbox: Box = None
-    area: float = None
-    length: float = None
-
-    @classmethod
-    def from_list(cls, args: List[Any]) -> "Arc":
-        return cls(
-            radius=args[1],
-            startAngle=args[2],
-            endAngle=args[3],
-            angleRadians=args[4],
-            domain=Interval.from_list(args[5:7]),
-            plane=Plane.from_list(args[7:20]),
-            units=get_units_from_encoding(args[-1]),
-        )
-
-    def to_list(self) -> List[Any]:
-        encoded = []
-        encoded.append(CurveTypeEncoding.Arc.value)
-        encoded.append(self.radius)
-        encoded.append(self.startAngle)
-        encoded.append(self.endAngle)
-        encoded.append(self.angleRadians)
-        encoded.extend(self.domain.to_list())
-        encoded.extend(self.plane.to_list())
-        encoded.append(get_encoding_from_units(self.units))
-        return encoded
-
-
-class Circle(Base, speckle_type=GEOMETRY + "Circle"):
-    radius: float = None
-    plane: Plane = None
-    domain: Interval = None
-    bbox: Box = None
-    area: float = None
-    length: float = None
-
-    @classmethod
-    def from_list(cls, args: List[Any]) -> "Circle":
-        return cls(
-            radius=args[1],
-            domain=Interval.from_list(args[2:4]),
-            plane=Plane.from_list(args[4:17]),
-            units=get_units_from_encoding(args[-1]),
-        )
-
-    def to_list(self) -> List[Any]:
-        encoded = []
-        encoded.append(CurveTypeEncoding.Circle.value)
-        encoded.append(self.radius),
-        encoded.extend(self.domain.to_list())
-        encoded.extend(self.plane.to_list())
-        encoded.append(get_encoding_from_units(self.units))
-        return encoded
-
-
-class Ellipse(Base, speckle_type=GEOMETRY + "Ellipse"):
-    firstRadius: float = None
-    secondRadius: float = None
-    plane: Plane = None
-    domain: Interval = None
-    trimDomain: Interval = None
-    bbox: Box = None
-    area: float = None
-    length: float = None
-
-    @classmethod
-    def from_list(cls, args: List[Any]) -> "Ellipse":
-        return cls(
-            firstRadius=args[1],
-            secondRadius=args[2],
-            domain=Interval.from_list(args[3:5]),
-            plane=Plane.from_list(args[5:18]),
-            units=get_units_from_encoding(args[-1]),
-        )
-
-    def to_list(self) -> List[Any]:
-        encoded = []
-        encoded.append(CurveTypeEncoding.Ellipse.value)
-        encoded.append(self.firstRadius)
-        encoded.append(self.secondRadius)
-        encoded.extend(self.domain.to_list())
-        encoded.extend(self.plane.to_list())
-        encoded.append(get_encoding_from_units(self.units))
-        return encoded
-
-
-class Polyline(Base, speckle_type=GEOMETRY + "Polyline", chunkable={"value": 20000}):
-    value: List[float] = None
-    closed: bool = None
-    domain: Interval = None
-    bbox: Box = None
-    area: float = None
-    length: float = None
-
-    @classmethod
-    def from_points(cls, points: List[Point]):
-        polyline = cls()
-        polyline.units = points[0].units
-        polyline.value = []
-        for point in points:
-            polyline.value.extend([point.x, point.y, point.z])
-        return polyline
-
-    @classmethod
-    def from_list(cls, args: List[Any]) -> "Polyline":
-        point_count = args[4]
-        return cls(
-            closed=bool(args[1]),
-            domain=Interval.from_list(args[2:4]),
-            value=args[5 : 5 + point_count],
-            units=get_units_from_encoding(args[-1]),
-        )
-
-    def to_list(self) -> List[Any]:
-        encoded = []
-        encoded.append(CurveTypeEncoding.Polyline.value)
-        encoded.append(int(self.closed))
-        encoded.extend(self.domain.to_list())
-        encoded.append(len(self.value))
-        encoded.extend(self.value)
-        encoded.append(get_encoding_from_units(self.units))
-        return encoded
-
-    def as_points(self) -> List[Point]:
-        """Converts the `value` attribute to a list of Points"""
-        if not self.value:
-            return
-
-        if len(self.value) % 3:
-            raise ValueError("Points array malformed: length%3 != 0.")
-
-        values = iter(self.value)
-        return [
-            Point(x=v, y=next(values), z=next(values), units=self.units) for v in values
-        ]
-
-
-class Curve(
-    Base,
-    speckle_type=GEOMETRY + "Curve",
-    chunkable={"points": 20000, "weights": 20000, "knots": 20000},
-):
-    degree: int = None
-    periodic: bool = None
-    rational: bool = None
-    points: List[float] = None
-    weights: List[float] = None
-    knots: List[float] = None
-    domain: Interval = None
-    displayValue: Polyline = None
-    closed: bool = None
-    bbox: Box = None
-    area: float = None
-    length: float = None
-
-    def as_points(self) -> List[Point]:
-        """Converts the `value` attribute to a list of Points"""
-        if not self.points:
-            return
-
-        if len(self.points) % 3:
-            raise ValueError("Points array malformed: length%3 != 0.")
-
-        values = iter(self.points)
-        return [
-            Point(x=v, y=next(values), z=next(values), units=self.units) for v in values
-        ]
-
-    @classmethod
-    def from_list(cls, args: List[Any]) -> "Curve":
-        point_count = args[7]
-        weights_count = args[8]
-        knots_count = args[9]
-
-        points_start = 10
-        weights_start = 10 + point_count
-        knots_start = weights_start + weights_count
-        knots_end = knots_start + knots_count
-
-        return cls(
-            degree=args[1],
-            periodic=bool(args[2]),
-            rational=bool(args[3]),
-            closed=bool(args[4]),
-            domain=Interval.from_list(args[5:7]),
-            points=args[points_start:weights_start],
-            weights=args[weights_start:knots_start],
-            knots=args[knots_start:knots_end],
-            units=get_units_from_encoding(args[-1]),
-        )
-
-    def to_list(self) -> List[Any]:
-        encoded = []
-        encoded.append(CurveTypeEncoding.Curve.value)
-        encoded.append(self.degree)
-        encoded.append(int(self.periodic))
-        encoded.append(int(self.rational))
-        encoded.append(int(self.closed))
-        encoded.extend(self.domain.to_list())
-        encoded.append(len(self.points))
-        encoded.append(len(self.weights))
-        encoded.append(len(self.knots))
-        encoded.extend(self.points)
-        encoded.extend(self.weights)
-        encoded.extend(self.knots)
-        encoded.append(get_encoding_from_units(self.units))
-        return encoded
-
-
-class Polycurve(Base, speckle_type=GEOMETRY + "Polycurve"):
-    segments: List[Base] = None
-    domain: Interval = None
-    closed: bool = None
-    bbox: Box = None
-    area: float = None
-    length: float = None
-
-    @classmethod
-    def from_list(cls, args: List[Any]) -> "Polycurve":
-        curve_arrays = CurveArray()
-        curve_arrays.data = args[4:-1]
-        return cls(
-            closed=bool(args[1]),
-            domain=Interval.from_list(args[2:4]),
-            segments=curve_arrays.to_curves(),
-            units=get_units_from_encoding(args[-1]),
-        )
-
-    def to_list(self) -> List[Any]:
-        encoded = []
-        encoded.append(CurveTypeEncoding.Polycurve.value)
-        encoded.append(int(self.closed))
-        encoded.extend(self.domain.to_list())
-        curve_array = CurveArray.from_curves(self.segments)
-        encoded.extend(curve_array.data)
-        encoded.append(get_encoding_from_units(self.units))
-        return encoded
-
-
-class Extrusion(Base, speckle_type=GEOMETRY + "Extrusion"):
-    capped: bool = None
-    profile: Base = None
-    pathStart: Point = None
-    pathEnd: Point = None
-    pathCurve: Base = None
-    pathTangent: Base = None
-    profiles: List[Base] = None
-    length: float = None
-    area: float = None
-    volume: float = None
-    bbox: Box = None
-
-
-class Mesh(
-    Base,
-    speckle_type=GEOMETRY + "Mesh",
-    chunkable={
-        "vertices": 2000,
-        "faces": 2000,
-        "colors": 2000,
-        "textureCoordinates": 2000,
-    },
-):
-    vertices: List[float] = None
-    faces: List[int] = None
-    colors: List[int] = None
-    textureCoordinates: List[float] = None
-    bbox: Box = None
-    area: float = None
-    volume: float = None
-
-
-class Surface(Base, speckle_type=GEOMETRY + "Surface"):
-    degreeU: int = None
-    degreeV: int = None
-    rational: bool = None
-    area: float = None
-    pointData: List[float] = None
-    countU: int = None
-    countV: int = None
-    bbox: Box = None
-    closedU: bool = None
-    closedV: bool = None
-    domainU: Interval = None
-    domainV: Interval = None
-    knotsU: List[float] = None
-    knotsV: List[float] = None
-
-    @classmethod
-    def from_list(cls, args: List[Any]) -> "Surface":
-        point_count = int(args[11])
-        knots_u_count = int(args[12])
-        knots_v_count = int(args[13])
-
-        start_point_data = 14
-        start_knots_u = start_point_data + point_count
-        start_knots_v = start_knots_u + knots_u_count
-
-        return cls(
-            degreeU=int(args[0]),
-            degreeV=int(args[1]),
-            countU=int(args[2]),
-            countV=int(args[3]),
-            rational=bool(args[4]),
-            closedU=bool(args[5]),
-            closedV=bool(args[6]),
-            domainU=Interval(start=args[7], end=args[8]),
-            domainV=Interval(start=args[9], end=args[10]),
-            pointData=args[start_point_data:start_knots_u],
-            knotsU=args[start_knots_u:start_knots_v],
-            knotsV=args[start_knots_v : start_knots_v + knots_v_count],
-            units=get_units_from_encoding(args[-1]),
-        )
-
-    def to_list(self) -> List[Any]:
-        encoded = []
-        encoded.append(self.degreeU)
-        encoded.append(self.degreeV)
-        encoded.append(self.countU)
-        encoded.append(self.countV)
-        encoded.append(int(self.rational))
-        encoded.append(int(self.closedU))
-        encoded.append(int(self.closedV))
-        encoded.extend(self.domainU.to_list())
-        encoded.extend(self.domainV.to_list())
-        encoded.append(len(self.pointData))
-        encoded.append(len(self.knotsU))
-        encoded.append(len(self.knotsV))
-        encoded.extend(self.pointData)
-        encoded.extend(self.knotsU)
-        encoded.extend(self.knotsV)
-        encoded.append(get_encoding_from_units(self.units))
-        return encoded
-
-
-class BrepFace(Base, speckle_type=GEOMETRY + "BrepFace"):
-    _Brep: "Brep" = None
-    SurfaceIndex: int = None
-    LoopIndices: List[int] = None
-    OuterLoopIndex: int = None
-    OrientationReversed: bool = None
-
-    @property
-    def _outer_loop(self):
-        return self._Brep.Loops[self.OuterLoopIndex]
-
-    @property
-    def _surface(self):
-        return self._Brep.Surfaces[self.SurfaceIndex]
-
-    @property
-    def _loops(self):
-        if self.LoopIndices:
-            return [self._Brep.Loops[i] for i in self.LoopIndices]
-
-
-class BrepEdge(Base, speckle_type=GEOMETRY + "BrepEdge"):
-    _Brep: "Brep" = None
-    Curve3dIndex: int = None
-    TrimIndices: List[int] = None
-    StartIndex: int = None
-    EndIndex: int = None
-    ProxyCurveIsReversed: bool = None
-    Domain: Interval = None
-
-    @property
-    def _start_vertex(self):
-        return self._Brep.Vertices[self.StartIndex]
-
-    @property
-    def _end_vertex(self):
-        return self._Brep.Vertices[self.EndIndex]
-
-    @property
-    def _trims(self):
-        if self.TrimIndices:
-            return [self._Brep.Trims[i] for i in self.TrimIndices]
-
-    @property
-    def _curve(self):
-        return self._Brep.Curve3D[self.Curve3dIndex]
-
-
-class BrepLoop(Base, speckle_type=GEOMETRY + "BrepLoop"):
-    _Brep: "Brep" = None
-    FaceIndex: int = None
-    TrimIndices: List[int] = None
-    Type: str = None
-
-    @property
-    def _face(self):
-        return self._Brep.Faces[self.FaceIndex]
-
-    @property
-    def _trims(self):
-        if self.TrimIndices:
-            return [self._Brep.Trims[i] for i in self.TrimIndices]
-
-
-class BrepTrimTypeEnum(int, Enum):
-    Unknown = 0
-    Boundary = 1
-    Mated = 2
-    Seam = 3
-    Singular = 4
-    CurveOnSurface = 5
-    PointOnSurface = 6
-    Slit = 7
-
-
-class BrepTrim(Base, speckle_type=GEOMETRY + "BrepTrim"):
-    _Brep: "Brep" = None
-    EdgeIndex: int = None
-    StartIndex: int = None
-    EndIndex: int = None
-    FaceIndex: int = None
-    LoopIndex: int = None
-    CurveIndex: int = None
-    IsoStatus: int = None
-    TrimType: str = None
-    IsReversed: bool = None
-    Domain: Interval = None
-
-    @property
-    def _face(self):
-        return self._Brep.Faces[self.FaceIndex]
-
-    @property
-    def _loop(self):
-        return self._Brep.Loops[self.LoopIndex]
-
-    @property
-    def _edge(self):
-        return self._Brep.Edges[self.EdgeIndex] if self.EdgeIndex != -1 else None
-
-    @property
-    def _curve_2d(self):
-        return self._Brep.Curve2D[self.CurveIndex]
-
-    @classmethod
-    def from_list(cls, args: List[Any]) -> "BrepTrim":
-        return cls(
-            EdgeIndex=args[0],
-            StartIndex=args[1],
-            EndIndex=args[2],
-            FaceIndex=args[3],
-            LoopIndex=args[4],
-            CurveIndex=args[5],
-            IsoStatus=args[6],
-            TrimType=BrepTrimTypeEnum(args[7]).name,
-            IsReversed=bool(args[8]),
-        )
-
-    def to_list(self) -> List[Any]:
-        encoded = []
-        encoded.append(self.EdgeIndex)
-        encoded.append(self.StartIndex)
-        encoded.append(self.EndIndex)
-        encoded.append(self.FaceIndex)
-        encoded.append(self.LoopIndex)
-        encoded.append(self.CurveIndex)
-        encoded.append(self.IsoStatus)
-        encoded.append(getattr(BrepTrimTypeEnum, self.TrimType).value)
-        encoded.append(self.IsReversed)
-        return encoded
-
-
-class Brep(
-    Base,
-    speckle_type=GEOMETRY + "Brep",
-    chunkable={
-        "SurfacesValue": 200,
-        "Curve3DValues": 200,
-        "Curve2DValues": 200,
-        "VerticesValue": 5000,
-        "Edges": 5000,
-        "Loops": 5000,
-        "TrimsValue": 5000,
-        "Faces": 5000,
-    },
-    detachable={"displayValue"},
-    serialize_ignore={"Surfaces", "Curve3D", "Curve2D", "Vertices", "Trims"},
-):
-    provenance: str = None
-    bbox: Box = None
-    area: float = None
-    volume: float = None
-    displayValue: Mesh = None
-    Surfaces: List[Surface] = None
-    Curve3D: List[Base] = None
-    Curve2D: List[Base] = None
-    Vertices: List[Point] = None
-    IsClosed: bool = None
-    Orientation: int = None
-
-    def _inject_self_into_children(self, children: Optional[List[Base]]) -> List[Base]:
-        if children is None:
-            return children
-
-        for child in children:
-            child._Brep = self
-        return children
-
-    @property
-    def Edges(self) -> List[BrepEdge]:
-        return self._inject_self_into_children(self._Edges)
-
-    @Edges.setter
-    def Edges(self, value: List[BrepEdge]):
-        self._Edges = value
-
-    @property
-    def Loops(self) -> List[BrepLoop]:
-        return self._inject_self_into_children(self._Loops)
-
-    @Loops.setter
-    def Loops(self, value: List[BrepLoop]):
-        self._Loops = value
-
-    @property
-    def Faces(self) -> List[BrepFace]:
-        return self._inject_self_into_children(self._Faces)
-
-    @Faces.setter
-    def Faces(self, value: List[BrepFace]):
-        self._Faces = value
-
-    @property
-    def SurfacesValue(self) -> List[float]:
-        if self.Surfaces is None:
-            return None
-        return ObjectArray.from_objects(self.Surfaces).data
-
-    @SurfacesValue.setter
-    def SurfacesValue(self, value: List[float]):
-        self.Surfaces = ObjectArray.decode_data(value, Surface.from_list)
-
-    @property
-    def Curve3DValues(self) -> List[float]:
-        if self.Curve3D is None:
-            return None
-        return CurveArray.from_curves(self.Curve3D).data
-
-    @Curve3DValues.setter
-    def Curve3DValues(self, value: List[float]):
-        crv_array = CurveArray()
-        crv_array.data = value
-        self.Curve3D = crv_array.to_curves()
-
-    @property
-    def Curve2DValues(self) -> List[Base]:
-        if self.Curve2D is None:
-            return None
-        return CurveArray.from_curves(self.Curve2D).data
-
-    @Curve2DValues.setter
-    def Curve2DValues(self, value: List[float]):
-        crv_array = CurveArray()
-        crv_array.data = value
-        self.Curve2D = crv_array.to_curves()
-
-    @property
-    def VerticesValue(self) -> List[Point]:
-        if self.Vertices is None:
-            return None
-        encoded_unit = get_encoding_from_units(self.Vertices[0].units)
-        values = [encoded_unit]
-        for vertex in self.Vertices:
-            values.extend(vertex.to_list())
-        return values
-
-    @VerticesValue.setter
-    def VerticesValue(self, value: List[float]):
-        value = value.copy()
-        units = get_units_from_encoding(value.pop(0))
-
-        vertices = []
-
-        for i in range(0, len(value), 3):
-            vertex = Point.from_list(value[i : i + 3])
-            vertex._units = units
-            vertices.append(vertex)
-
-        self.Vertices = vertices
-
-    @property
-    def Trims(self) -> List[BrepTrim]:
-        return self._inject_self_into_children(self._Trims)
-
-    @Trims.setter
-    def Trims(self, value: List[BrepTrim]):
-        self._Trims = value
-
-    @property
-    def TrimsValue(self) -> List[float]:
-        if self.Trims is None:
-            return None
-        values = []
-        for trim in self.Trims:
-            values.extend(trim.to_list())
-        return values
-
-    @TrimsValue.setter
-    def TrimsValue(self, value: List[float]):
-        self.Trims = [
-            BrepTrim.from_list(value[i : i + 9]) for i in range(0, len(value), 9)
-        ]
-
-
-BrepEdge.update_forward_refs()
-BrepLoop.update_forward_refs()
-BrepTrim.update_forward_refs()
-BrepFace.update_forward_refs()

specklepy/objects/other.py

@@ -1,199 +0,0 @@
-from typing import List
-from specklepy.objects.geometry import Point, Vector
-from .base import Base
-
-OTHER = "Objects.Other."
-
-IDENTITY_TRANSFORM = [
-    1.0,
-    0.0,
-    0.0,
-    0.0,
-    0.0,
-    1.0,
-    0.0,
-    0.0,
-    0.0,
-    0.0,
-    1.0,
-    0.0,
-    0.0,
-    0.0,
-    0.0,
-    1.0,
-]
-
-
-class RenderMaterial(Base, speckle_type=OTHER + "RenderMaterial"):
-    name: str = None
-    opacity: float = 1
-    metalness: float = 0
-    roughness: float = 1
-    diffuse: int = -2894893  # light gray arbg
-    emissive: int = -16777216  # black arbg
-
-
-class Transform(
-    Base,
-    speckle_type=OTHER + "Transform",
-    serialize_ignore={"translation", "scaling", "is_identity"},
-):
-    """The 4x4 transformation matrix
-
-    The 3x3 sub-matrix determines scaling.
-    The 4th column defines translation, where the last value is a divisor (usually equal to 1).
-    """
-
-    _value: List[float] = None
-
-    @property
-    def value(self) -> List[float]:
-        """The transform matrix represented as a flat list of 16 floats"""
-        return self._value
-
-    @value.setter
-    def value(self, value: List[float]) -> None:
-        try:
-            value = [float(x) for x in value]
-        except (ValueError, TypeError):
-            raise ValueError(
-                f"Could not create a Transform object with the requested value. Input must be a 16 element list of numbers. Value provided: {value}"
-            )
-        if len(value) != 16:
-            raise ValueError(
-                f"Could not create a Transform object: input list should be 16 floats long, but was {len(value)} long"
-            )
-
-        self._value = value
-
-    @property
-    def translation(self) -> List[float]:
-        """The final column of the matrix which defines the translation"""
-        return [self._value[i] for i in (3, 7, 11, 15)]
-
-    @property
-    def scaling(self) -> List[float]:
-        """The 3x3 scaling sub-matrix"""
-        return [self._value[i] for i in (0, 1, 2, 4, 5, 6, 8, 9, 10)]
-
-    @property
-    def is_identity(self) -> bool:
-        return self.value == IDENTITY_TRANSFORM
-
-    def apply_to_point(self, point: Point) -> Point:
-        """Transform a single speckle Point
-
-        Arguments:
-            point {Point} -- the speckle Point to transform
-
-        Returns:
-            Point -- a new transformed point
-        """
-        coords = self.apply_to_point_value([point.x, point.y, point.z])
-        return Point(x=coords[0], y=coords[1], z=coords[2], units=point.units)
-
-    def apply_to_point_value(self, point_value: List[float]) -> List[float]:
-        """Transform a list of three floats representing a point
-
-        Arguments:
-            point_value {List[float]} -- a list of 3 floats
-
-        Returns:
-            List[float] -- the list with the transform applied
-        """
-        transformed = [
-            point_value[0] * self._value[i]
-            + point_value[1] * self._value[i + 1]
-            + point_value[2] * self._value[i + 2]
-            + self._value[i + 3]
-            for i in range(0, 15, 4)
-        ]
-
-        return [transformed[i] / transformed[3] for i in range(3)]
-
-    def apply_to_points(self, points: List[Point]) -> List[Point]:
-        """Transform a list of speckle Points
-
-        Arguments:
-            points {List[Point]} -- the list of speckle Points to transform
-
-        Returns:
-            List[Point] -- a new list of transformed points
-        """
-        return [self.apply_to_point(point) for point in points]
-
-    def apply_to_points_values(self, points_value: List[float]) -> List[float]:
-        """Transform a list of speckle Points
-
-        Arguments:
-            points {List[float]} -- a flat list of floats representing points to transform
-
-        Returns:
-            List[float] -- a new transformed list
-        """
-        if len(points_value) % 3 != 0:
-            raise ValueError(
-                "Cannot apply transform as the points list is malformed: expected length to be multiple of 3"
-            )
-        transformed = []
-        for i in range(0, len(points_value), 3):
-            transformed.extend(self.apply_to_point_value(points_value[i : i + 3]))
-
-        return transformed
-
-    def apply_to_vector(self, vector: Vector) -> Vector:
-        """Transform a single speckle Vector
-
-        Arguments:
-            point {Vector} -- the speckle Vector to transform
-
-        Returns:
-            Vector -- a new transformed point
-        """
-        coords = self.apply_to_vector_value([vector.x, vector.y, vector.z])
-        return Vector(x=coords[0], y=coords[1], z=coords[2], units=vector.units)
-
-    def apply_to_vector_value(self, vector_value: List[float]) -> List[float]:
-        """Transform a list of three floats representing a vector
-
-        Arguments:
-            vector_value {List[float]} -- a list of 3 floats
-
-        Returns:
-            List[float] -- the list with the transform applied
-        """
-        return [
-            vector_value[0] * self._value[i]
-            + vector_value[1] * self._value[i + 1]
-            + vector_value[2] * self._value[i + 2]
-            for i in range(0, 15, 4)
-        ][:3]
-
-    @classmethod
-    def from_list(cls, value: List[float] = None) -> "Transform":
-        """Returns a Transform object from a list of 16 numbers. If no value is provided, an identity transform will be returned.
-
-        Arguments:
-            value {List[float]} -- the matrix as a flat list of 16 numbers (defaults to the identity transform)
-
-        Returns:
-            Transform -- a complete transform object
-        """
-        if not value:
-            value = IDENTITY_TRANSFORM
-        return cls(value=value)
-
-
-class BlockDefinition(
-    Base, speckle_type=OTHER + "BlockDefinition", detachable={"geometry"}
-):
-    name: str = None
-    basePoint: Point = None
-    geometry: List[Base] = None
-
-
-class BlockInstance(
-    Base, speckle_type=OTHER + "BlockInstance", detachable={"blockDefinition"}
-):
-    blockDefinition: BlockDefinition = None
-    transform: Transform = None

specklepy/objects/units.py

@@ -1,57 +0,0 @@
-from specklepy.logging.exceptions import SpeckleException
-
-UNITS = ["mm", "cm", "m", "in", "ft", "yd", "mi"]
-
-UNITS_STRINGS = {
-    "mm": ["mm", "mil", "millimeters", "millimetres"],
-    "cm": ["cm", "centimetre", "centimeter", "centimetres", "centimeters"],
-    "m": ["m", "meter", "meters", "metre", "metres"],
-    "km": ["km", "kilometer", "kilometre", "kilometers", "kilometres"],
-    "in": ["in", "inch", "inches"],
-    "ft": ["ft", "foot", "feet"],
-    "yd": ["yd", "yard", "yards"],
-    "mi": ["mi", "mile", "miles"],
-    "none": ["none", "null"],
-}
-
-UNITS_ENCODINGS = {
-    "none": 0,
-    "mm": 1,
-    "cm": 2,
-    "m": 3,
-    "km": 4,
-    "in": 5,
-    "ft": 6,
-    "yd": 7,
-    "mi": 8,
-}
-
-
-def get_units_from_string(unit: str):
-    unit = str.lower(unit)
-    for name, alternates in UNITS_STRINGS.items():
-        if unit in alternates:
-            return name
-
-    raise SpeckleException(
-        message=f"Could not understand what unit {unit} is referring to. Please enter a valid unit (eg {UNITS})."
-    )
-
-
-def get_units_from_encoding(unit: int):
-    for name, encoding in UNITS_ENCODINGS.items():
-        if unit == encoding:
-            return name
-
-    raise SpeckleException(
-        message=f"Could not understand what unit {unit} is referring to. Please enter a valid unit encoding (eg {UNITS_ENCODINGS})."
-    )
-
-
-def get_encoding_from_units(unit: str):
-    try:
-        return UNITS_ENCODINGS[unit]
-    except KeyError:
-        raise SpeckleException(
-            message=f"No encoding exists for unit {unit}. Please enter a valid unit to encode (eg {UNITS_ENCODINGS})."
-        )

specklepy/transports/server/__init__.py

@@ -1 +0,0 @@
-from .server import ServerTransport

src/speckle_automate/__init__.py

@@ -0,0 +1,24 @@
+"""This module contains an SDK for working with Speckle Automate."""
+
+from speckle_automate.automation_context import AutomationContext
+from speckle_automate.runner import execute_automate_function, run_function
+from speckle_automate.schema import (
+    AutomateBase,
+    AutomationResult,
+    AutomationRunData,
+    AutomationStatus,
+    ObjectResultLevel,
+    ResultCase,
+)
+
+__all__ = [
+    "AutomationContext",
+    "AutomateBase",
+    "AutomationStatus",
+    "AutomationResult",
+    "AutomationRunData",
+    "ResultCase",
+    "ObjectResultLevel",
+    "run_function",
+    "execute_automate_function",
+]

src/speckle_automate/automation_context.py

@@ -0,0 +1,493 @@
+"""This module provides an abstraction layer above the Speckle Automate runtime."""
+
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+
+import httpx
+from gql import gql
+
+from speckle_automate.schema import (
+    AutomateBase,
+    AutomationResult,
+    AutomationRunData,
+    AutomationStatus,
+    ObjectResultLevel,
+    ResultCase,
+)
+from specklepy.api import operations
+from specklepy.api.client import SpeckleClient
+from specklepy.core.api.inputs.model_inputs import CreateModelInput
+from specklepy.core.api.inputs.version_inputs import CreateVersionInput
+from specklepy.core.api.models.current import Model, Version
+from specklepy.logging.exceptions import SpeckleException
+from specklepy.objects.base import Base
+from specklepy.transports.memory import MemoryTransport
+from specklepy.transports.server import ServerTransport
+
+
+@dataclass
+class AutomationContext:
+    """A context helper class.
+
+    This class exposes methods to work with the Speckle Automate context inside
+    Speckle Automate functions.
+
+    An instance of AutomationContext is injected into every run of a function.
+    """
+
+    automation_run_data: AutomationRunData
+    speckle_client: SpeckleClient
+    _server_transport: ServerTransport
+    _speckle_token: str
+
+    #: keep a memory transponrt at hand, to speed up things if needed
+    _memory_transport: MemoryTransport = field(default_factory=MemoryTransport)
+
+    #: added for performance measuring
+    _init_time: float = field(default_factory=time.perf_counter)
+    _automation_result: AutomationResult = field(default_factory=AutomationResult)
+
+    @classmethod
+    def initialize(
+        cls, automation_run_data: Union[str, AutomationRunData], speckle_token: str
+    ) -> "AutomationContext":
+        """Bootstrap the AutomateSDK from raw data.
+
+        Todo:
+        ----
+            * bootstrap a structlog logger instance
+            * expose a logger, that ppl can use instead of print
+        """
+        # parse the json value if its not an initialized project data instance
+        automation_run_data = (
+            automation_run_data
+            if isinstance(automation_run_data, AutomationRunData)
+            else AutomationRunData.model_validate_json(automation_run_data)
+        )
+        speckle_client = SpeckleClient(
+            automation_run_data.speckle_server_url,
+            automation_run_data.speckle_server_url.startswith("https"),
+        )
+        speckle_client.authenticate_with_token(speckle_token)
+        if not speckle_client.account:
+            msg = (
+                f"Could not authenticate to {automation_run_data.speckle_server_url}",
+                "with the provided token",
+            )
+            raise ValueError(msg)
+        server_transport = ServerTransport(
+            automation_run_data.project_id, speckle_client
+        )
+        return cls(automation_run_data, speckle_client, server_transport, speckle_token)
+
+    @property
+    def run_status(self) -> AutomationStatus:
+        """Get the status of the automation run."""
+        return self._automation_result.run_status
+
+    @property
+    def status_message(self) -> Optional[str]:
+        """Get the current status message."""
+        return self._automation_result.status_message
+
+    def elapsed(self) -> float:
+        """Return the elapsed time in seconds since the initialization time."""
+        return time.perf_counter() - self._init_time
+
+    def receive_version(self) -> Base:
+        """Receive the Speckle project version that triggered this automation run."""
+        # TODO: this is a quick hack to keep implementation consistency.
+        # Move to proper receive many versions
+        version_id = self.automation_run_data.triggers[0].payload.version_id
+        try:
+            version = self.speckle_client.version.get(
+                version_id, self.automation_run_data.project_id
+            )
+        except SpeckleException as err:
+            raise ValueError(
+                f"""Could not receive specified version.
+                Is your environment configured correctly?
+                project_id: {self.automation_run_data.project_id}
+                model_id: {self.automation_run_data.triggers[0].payload.model_id}
+                version_id: {self.automation_run_data.triggers[0].payload.version_id}
+                """
+            ) from err
+
+        if not version.referenced_object:
+            raise Exception(
+                "This version is past the version history limit,",
+                " cannot execute an automation on it",
+            )
+
+        base = operations.receive(
+            version.referenced_object, self._server_transport, self._memory_transport
+        )
+        # self._closure_tree = base["__closure"]
+        print(
+            f"It took {self.elapsed():.2f} seconds to receive",
+            f" the speckle version {version_id}",
+        )
+        return base
+
+    def create_new_model_in_project(
+        self, model_name: str, model_description: Optional[str] = None
+    ) -> Model:
+        input = CreateModelInput(
+            name=model_name,
+            description=model_description,
+            project_id=self.automation_run_data.project_id,
+        )
+
+        return self.speckle_client.model.create(input)
+
+    def get_model(self, model_id: str) -> Model:
+        """
+        Args:
+            model_id (str): The id of the model to get
+        """
+        return self.speckle_client.model.get(
+            model_id, self.automation_run_data.project_id
+        )
+
+    def create_new_version_in_project(
+        self, root_object: Base, model_id: str, version_message: str = ""
+    ) -> Version:
+        """Save a base model to a new version on the project.
+
+        Args:
+            root_object (Base): The Speckle base object for the new version.
+            model_id (str): Id of model to create the new version on.
+            version_message (str): The message for the new version.
+        """
+
+        matching_trigger = [
+            t
+            for t in self.automation_run_data.triggers
+            if t.payload.model_id == model_id
+        ]
+        if matching_trigger:
+            raise ValueError(
+                f"The target model: {model_id} cannot match the model"
+                f" that triggered this automation:"
+                f" {matching_trigger[0].payload.model_id}"
+            )
+
+        root_object_id = operations.send(
+            root_object,
+            [self._server_transport, self._memory_transport],
+            use_default_cache=False,
+        )
+
+        create_version_input = CreateVersionInput(
+            object_id=root_object_id,
+            model_id=model_id,
+            project_id=self.automation_run_data.project_id,
+            message=version_message,
+            source_application="SpeckleAutomate",
+        )
+        version = self.speckle_client.version.create(create_version_input)
+
+        self._automation_result.result_versions.append(version.id)
+        return version
+
+    @property
+    def context_view(self) -> Optional[str]:
+        return self._automation_result.result_view
+
+    def set_context_view(
+        self,
+        # f"{model_id}@{version_id} or {model_id} "
+        resource_ids: Optional[List[str]] = None,
+        include_source_model_version: bool = True,
+    ) -> None:
+        link_resources = (
+            [
+                f"{t.payload.model_id}@{t.payload.version_id}"
+                for t in self.automation_run_data.triggers
+            ]
+            if include_source_model_version
+            else []
+        )
+        if resource_ids:
+            link_resources.extend(resource_ids)
+        if not link_resources:
+            raise Exception(
+                "We do not have enough resource ids to compose a context view"
+            )
+        self._automation_result.result_view = (
+            f"/projects/{self.automation_run_data.project_id}"
+            f"/models/{','.join(link_resources)}"
+        )
+
+    def report_run_status(self) -> None:
+        """Report the current run status to the project of this automation."""
+        query = gql(
+            """
+            mutation AutomateFunctionRunStatusReport(
+                $projectId: String!
+                $functionRunId: String!
+                $status: AutomateRunStatus!
+                $statusMessage: String
+                $results: JSONObject
+                $contextView: String
+            ){
+                automateFunctionRunStatusReport(input: {
+                    projectId: $projectId
+                    functionRunId: $functionRunId
+                    status: $status
+                    statusMessage: $statusMessage
+                    contextView: $contextView
+                    results: $results
+                })
+            }
+        """
+        )
+        if self.run_status in [AutomationStatus.SUCCEEDED, AutomationStatus.FAILED]:
+            object_results = {
+                "version": 2,
+                "values": {
+                    "objectResults": self._automation_result.model_dump(by_alias=True)[
+                        "objectResults"
+                    ],
+                    "blobIds": self._automation_result.blobs,
+                },
+            }
+        else:
+            object_results = None
+
+        params = {
+            "projectId": self.automation_run_data.project_id,
+            "functionRunId": self.automation_run_data.function_run_id,
+            "status": self.run_status.value,
+            "statusMessage": self._automation_result.status_message,
+            "results": object_results,
+            "contextView": self._automation_result.result_view,
+        }
+        print(f"Reporting run status with content: {params}")
+        self.speckle_client.httpclient.execute(query, params)
+
+    def store_file_result(self, file_path: Union[Path, str]) -> None:
+        """Save a file attached to the project of this automation."""
+        path_obj = (
+            Path(file_path).resolve() if isinstance(file_path, str) else file_path
+        )
+
+        class UploadResult(AutomateBase):
+            blob_id: str
+            file_name: str
+            upload_status: int
+
+        class BlobUploadResponse(AutomateBase):
+            upload_results: list[UploadResult]
+
+        if not path_obj.exists():
+            raise ValueError("The given file path doesn't exist")
+
+        files = {path_obj.name: path_obj.open("rb")}
+
+        url = (
+            f"{self.automation_run_data.speckle_server_url}api/stream/"
+            f"{self.automation_run_data.project_id}/blob"
+        )
+        data = (
+            httpx.post(
+                url,
+                files=files,
+                headers={"authorization": f"Bearer {self._speckle_token}"},
+            )
+            .raise_for_status()
+            .json()
+        )
+
+        upload_response = BlobUploadResponse.model_validate(data)
+
+        if len(upload_response.upload_results) != 1:
+            raise ValueError("Expecting one upload result.")
+
+        self._automation_result.blobs.extend(
+            [upload_result.blob_id for upload_result in upload_response.upload_results]
+        )
+
+    def mark_run_failed(self, status_message: str) -> None:
+        """Mark the current run a failure."""
+        self._mark_run(AutomationStatus.FAILED, status_message)
+
+    def mark_run_exception(self, status_message: str) -> None:
+        """Mark the current run a failure."""
+        self._mark_run(AutomationStatus.EXCEPTION, status_message)
+
+    def mark_run_success(self, status_message: Optional[str]) -> None:
+        """Mark the current run a success with an optional message."""
+        self._mark_run(AutomationStatus.SUCCEEDED, status_message)
+
+    def _mark_run(
+        self, status: AutomationStatus, status_message: Optional[str]
+    ) -> None:
+        duration = self.elapsed()
+        self._automation_result.status_message = status_message
+        self._automation_result.run_status = status
+        self._automation_result.elapsed = duration
+
+        msg = f"Automation run {status.value} after {duration:.2f} seconds."
+        print("\n".join([msg, status_message]) if status_message else msg)
+
+    def attach_error_to_objects(
+        self,
+        category: str,
+        affected_objects: Union[Base, List[Base]],
+        message: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        visual_overrides: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        """Add a new error case to the run results.
+        Args:
+            category (str): A short tag for the event type.
+            affected_objects (Union[Base, List[Base]]): A single object or a list of
+                objects that are causing the error case.
+            message (Optional[str]): Optional message.
+            metadata: User provided metadata key value pairs
+            visual_overrides: Case specific 3D visual overrides.
+        """
+        self.attach_result_to_objects(
+            ObjectResultLevel.ERROR,
+            category,
+            affected_objects,
+            message,
+            metadata,
+            visual_overrides,
+        )
+
+    def attach_warning_to_objects(
+        self,
+        category: str,
+        affected_objects: Union[Base, List[Base]],
+        message: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        visual_overrides: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        """Add a new warning case to the run results.
+
+        Args:
+            category (str): A short tag for the event type.
+            affected_objects (Union[Base, List[Base]]): A single object or a list of
+                objects that are causing the warning case.
+            message (Optional[str]): Optional message.
+            metadata: User provided metadata key value pairs
+            visual_overrides: Case specific 3D visual overrides.
+        """
+        self.attach_result_to_objects(
+            ObjectResultLevel.WARNING,
+            category,
+            affected_objects,
+            message,
+            metadata,
+            visual_overrides,
+        )
+
+    def attach_success_to_objects(
+        self,
+        category: str,
+        affected_objects: Union[Base, List[Base]],
+        message: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        visual_overrides: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        """Add a new success case to the run results.
+
+        Args:
+            category (str): A short tag for the event type.
+            affected_objects (Union[Base, List[Base]]): A single object or a list of
+                objects that are causing the success case.
+            message (Optional[str]): Optional message.
+            metadata: User provided metadata key value pairs
+            visual_overrides: Case specific 3D visual overrides.
+        """
+        self.attach_result_to_objects(
+            ObjectResultLevel.SUCCESS,
+            category,
+            affected_objects,
+            message,
+            metadata,
+            visual_overrides,
+        )
+
+    def attach_info_to_objects(
+        self,
+        category: str,
+        affected_objects: Union[Base, List[Base]],
+        message: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        visual_overrides: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        """Add a new info case to the run results.
+
+        Args:
+            category (str): A short tag for the event type.
+            affected_objects (Union[Base, List[Base]]): A single object or a list of
+                objects that are causing the info case.
+            message (Optional[str]): Optional message.
+            metadata: User provided metadata key value pairs
+            visual_overrides: Case specific 3D visual overrides.
+        """
+        self.attach_result_to_objects(
+            ObjectResultLevel.INFO,
+            category,
+            affected_objects,
+            message,
+            metadata,
+            visual_overrides,
+        )
+
+    def attach_result_to_objects(
+        self,
+        level: ObjectResultLevel,
+        category: str,
+        affected_objects: Union[Base, List[Base]],
+        message: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        visual_overrides: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        """Add a new result case to the run results.
+
+        Args:
+            level: Result level.
+            category (str): A short tag for the event type.
+            affected_objects (Union[Base, List[Base]]): A single object or a list of
+                objects that are causing the info case.
+            message (Optional[str]): Optional message.
+            metadata: User provided metadata key value pairs
+            visual_overrides: Case specific 3D visual overrides.
+        """
+        if isinstance(affected_objects, list):
+            if len(affected_objects) < 1:
+                raise ValueError(
+                    f"Need atleast one object to report a(n) {level.value.upper()}"
+                )
+            object_list = affected_objects
+        else:
+            object_list = [affected_objects]
+
+        ids: Dict[str, Optional[str]] = {}
+        for o in object_list:
+            # validate that the Base.id is not None. If its a None, throw an Exception
+            if not o.id:
+                raise Exception(
+                    f"You can only attach {level} results to objects with an id."
+                )
+            ids[o.id] = o.applicationId
+        print(
+            f"Created new {level.value.upper()}"
+            f" category: {category} caused by: {message}"
+        )
+        self._automation_result.object_results.append(
+            ResultCase(
+                category=category,
+                level=level,
+                object_app_ids=ids,
+                message=message,
+                metadata=metadata,
+                visual_overrides=visual_overrides,
+            )
+        )

src/speckle_automate/fixtures.py

@@ -0,0 +1,155 @@
+"""Some useful helpers for working with automation data."""
+
+import secrets
+import string
+
+import pytest
+from gql import gql
+from pydantic import Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+from speckle_automate.schema import AutomationRunData, TestAutomationRunData
+from specklepy.api.client import SpeckleClient
+
+
+class TestAutomationEnvironment(BaseSettings):
+    """Get known environment variables from local `.env` file"""
+
+    model_config = SettingsConfigDict(
+        env_file=".env",
+        env_file_encoding="utf-8",
+        env_prefix="speckle_",
+        extra="ignore",
+    )
+
+    token: str = Field()
+    server_url: str = Field()
+    project_id: str = Field()
+    automation_id: str = Field()
+
+
+@pytest.fixture()
+def test_automation_environment() -> TestAutomationEnvironment:
+    return TestAutomationEnvironment()
+
+
+@pytest.fixture()
+def test_automation_token(
+    test_automation_environment: TestAutomationEnvironment,
+) -> str:
+    """Provide a speckle token for the test suite."""
+
+    return test_automation_environment.token
+
+
+@pytest.fixture()
+def speckle_client(
+    test_automation_environment: TestAutomationEnvironment,
+) -> SpeckleClient:
+    """Initialize a SpeckleClient for testing."""
+    speckle_client = SpeckleClient(
+        test_automation_environment.server_url,
+        test_automation_environment.server_url.startswith("https"),
+    )
+    speckle_client.authenticate_with_token(test_automation_environment.token)
+    return speckle_client
+
+
+def create_test_automation_run(
+    speckle_client: SpeckleClient, project_id: str, test_automation_id: str
+) -> TestAutomationRunData:
+    """Create test run to report local test results to"""
+
+    query = gql(
+        """
+        mutation CreateTestRun(
+            $projectId: ID!,
+            $automationId: ID!
+        ) {
+            projectMutations {
+                automationMutations(projectId: $projectId) {
+                    createTestAutomationRun(automationId: $automationId) {
+                        automationRunId
+                        functionRunId
+                        triggers {
+                            payload {
+                                modelId
+                                versionId
+                            }
+                            triggerType
+                        }
+                    }
+                }
+            }
+        }
+        """
+    )
+
+    params = {"automationId": test_automation_id, "projectId": project_id}
+
+    result = speckle_client.httpclient.execute(query, params)
+
+    print(result)
+
+    return (
+        result.get("projectMutations")
+        .get("automationMutations")
+        .get("createTestAutomationRun")
+    )
+
+
+@pytest.fixture()
+def test_automation_run(
+    speckle_client: SpeckleClient,
+    test_automation_environment: TestAutomationEnvironment,
+) -> TestAutomationRunData:
+    return create_test_automation_run(
+        speckle_client,
+        test_automation_environment.project_id,
+        test_automation_environment.automation_id,
+    )
+
+
+def create_test_automation_run_data(
+    speckle_client: SpeckleClient,
+    test_automation_environment: TestAutomationEnvironment,
+) -> AutomationRunData:
+    """Create automation run data for a new run for a given test automation"""
+
+    test_automation_run_data = create_test_automation_run(
+        speckle_client,
+        test_automation_environment.project_id,
+        test_automation_environment.automation_id,
+    )
+
+    return AutomationRunData(
+        project_id=test_automation_environment.project_id,
+        speckle_server_url=test_automation_environment.server_url,
+        automation_id=test_automation_environment.automation_id,
+        automation_run_id=test_automation_run_data["automationRunId"],
+        function_run_id=test_automation_run_data["functionRunId"],
+        triggers=test_automation_run_data["triggers"],
+    )
+
+
+@pytest.fixture()
+def test_automation_run_data(
+    speckle_client: SpeckleClient,
+    test_automation_environment: TestAutomationEnvironment,
+) -> AutomationRunData:
+    return create_test_automation_run_data(speckle_client, test_automation_environment)
+
+
+def crypto_random_string(length: int) -> str:
+    """Generate a semi crypto random string of a given length."""
+    alphabet = string.ascii_letters + string.digits
+    return "".join(secrets.choice(alphabet) for _ in range(length)).lower()
+
+
+__all__ = [
+    "test_automation_environment",
+    "test_automation_token",
+    "speckle_client",
+    "test_automation_run",
+    "test_automation_run_data",
+]

src/speckle_automate/runner.py

@@ -0,0 +1,194 @@
+"""Function execution module.
+
+Provides mechanisms to execute any function,
+ that conforms to the AutomateFunction "interface"
+"""
+
+import json
+import sys
+import traceback
+from pathlib import Path
+from typing import Callable, Optional, Tuple, TypeVar, Union, overload
+
+from pydantic import create_model
+from pydantic.json_schema import GenerateJsonSchema
+
+from speckle_automate.automation_context import AutomationContext
+from speckle_automate.schema import AutomateBase, AutomationRunData, AutomationStatus
+
+T = TypeVar("T", bound=AutomateBase)
+
+AutomateFunction = Callable[[AutomationContext, T], None]
+AutomateFunctionWithoutInputs = Callable[[AutomationContext], None]
+
+
+def _read_input_data(inputs_location: str) -> str:
+    input_path = Path(inputs_location)
+    if not input_path.exists():
+        raise ValueError(f"Cannot find the function inputs file at {input_path}")
+
+    return input_path.read_text()
+
+
+def _parse_input_data(
+    input_location: str, input_schema: Optional[type[T]]
+) -> Tuple[AutomationRunData, Optional[T], str]:
+    input_json_string = _read_input_data(input_location)
+
+    class FunctionRunData(AutomateBase):
+        speckle_token: str
+        automation_run_data: AutomationRunData
+        function_inputs: None = None
+
+    parser_model = FunctionRunData
+
+    if input_schema:
+        parser_model = create_model(
+            "FunctionRunDataWithInputs",
+            function_inputs=(input_schema, ...),
+            __base__=FunctionRunData,
+        )
+
+    input_data = parser_model.model_validate_json(input_json_string)
+    return (
+        input_data.automation_run_data,
+        input_data.function_inputs,
+        input_data.speckle_token,
+    )
+
+
+@overload
+def execute_automate_function(
+    automate_function: AutomateFunction[T],
+    input_schema: type[T],
+) -> None: ...
+
+
+@overload
+def execute_automate_function(
+    automate_function: AutomateFunctionWithoutInputs,
+) -> None: ...
+
+
+class AutomateGenerateJsonSchema(GenerateJsonSchema):
+    def generate(self, schema, mode="validation"):
+        json_schema = super().generate(schema, mode=mode)
+        json_schema["$schema"] = self.schema_dialect
+        return json_schema
+
+
+def execute_automate_function(
+    automate_function: Union[AutomateFunction[T], AutomateFunctionWithoutInputs],
+    input_schema: Optional[type[T]] = None,
+):
+    """Runs the provided automate function with the input schema."""
+    # first arg is the python file name, we do not need that
+    args = sys.argv[1:]
+
+    if len(args) != 2:
+        raise ValueError("Incorrect number of arguments specified need 2")
+
+    # we rely on a command name convention to decide what to do.
+    # this is here, so that the function authors do not see any of this
+    command, argument = args
+
+    if command == "generate_schema":
+        path = Path(argument)
+        schema = json.dumps(
+            input_schema.model_json_schema(
+                by_alias=True, schema_generator=AutomateGenerateJsonSchema
+            )
+            if input_schema
+            else {}
+        )
+        path.write_text(schema)
+
+    elif command == "run":
+        automation_run_data, function_inputs, speckle_token = _parse_input_data(
+            argument, input_schema
+        )
+
+        automation_context = AutomationContext.initialize(
+            automation_run_data, speckle_token
+        )
+
+        if function_inputs:
+            automation_context = run_function(
+                automation_context,
+                automate_function,  # type: ignore
+                function_inputs,  # type: ignore
+            )
+
+        else:
+            automation_context = AutomationContext.initialize(
+                automation_run_data, speckle_token
+            )
+            automation_context = run_function(
+                automation_context,
+                automate_function,  # type: ignore
+            )
+
+        # if we've gotten this far,
+        # the execution should technically be completed as expected
+        # thus exiting with 0 is the schemantically correct thing to do
+        exit_code = (
+            1 if automation_context.run_status == AutomationStatus.EXCEPTION else 0
+        )
+        exit(exit_code)
+
+    else:
+        raise NotImplementedError(f"Command: '{command}' is not supported.")
+
+
+@overload
+def run_function(
+    automation_context: AutomationContext,
+    automate_function: AutomateFunction[T],
+    inputs: T,
+) -> AutomationContext: ...
+
+
+@overload
+def run_function(
+    automation_context: AutomationContext,
+    automate_function: AutomateFunctionWithoutInputs,
+) -> AutomationContext: ...
+
+
+def run_function(
+    automation_context: AutomationContext,
+    automate_function: Union[AutomateFunction[T], AutomateFunctionWithoutInputs],
+    inputs: Optional[T] = None,
+) -> AutomationContext:
+    """Run the provided function with the automate sdk context."""
+    automation_context.report_run_status()
+
+    try:
+        # avoiding complex type gymnastics here on the internals.
+        # the external type overloads make this correct
+        if inputs:
+            automate_function(automation_context, inputs)  # type: ignore
+        else:
+            automate_function(automation_context)  # type: ignore
+
+        # the function author forgot to mark the function success
+        if automation_context.run_status not in [
+            AutomationStatus.FAILED,
+            AutomationStatus.SUCCEEDED,
+            AutomationStatus.EXCEPTION,
+        ]:
+            automation_context.mark_run_success(
+                "WARNING: Automate assumed a success status,"
+                " but it was not marked as so by the function."
+            )
+    except Exception:
+        trace = traceback.format_exc()
+        print(trace)
+        automation_context.mark_run_exception(
+            "Function error. Check the automation run logs for details."
+        )
+    finally:
+        if not automation_context.context_view:
+            automation_context.set_context_view()
+        automation_context.report_run_status()
+    return automation_context

src/speckle_automate/schema.py

@@ -0,0 +1,98 @@
+""""""
+
+from enum import Enum
+from typing import Any, Dict, List, Literal, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+from pydantic.alias_generators import to_camel
+
+
+class AutomateBase(BaseModel):
+    """Use this class as a base model for automate related DTO."""
+
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+
+
+class VersionCreationTriggerPayload(AutomateBase):
+    """Represents the version creation trigger payload."""
+
+    model_id: str
+    version_id: str
+
+
+class VersionCreationTrigger(AutomateBase):
+    """Represents a single version creation trigger for the automation run."""
+
+    trigger_type: Literal["versionCreation"]
+    payload: VersionCreationTriggerPayload
+
+
+class AutomationRunData(BaseModel):
+    """Values of the project / model that triggered the run of this function."""
+
+    project_id: str
+    speckle_server_url: str
+    automation_id: str
+    automation_run_id: str
+    function_run_id: str
+
+    triggers: List[VersionCreationTrigger]
+
+    model_config = ConfigDict(
+        alias_generator=to_camel, populate_by_name=True, protected_namespaces=()
+    )
+
+
+class TestAutomationRunData(BaseModel):
+    """Values of the run created in the test automation for local test results."""
+
+    automation_run_id: str
+    function_run_id: str
+
+    triggers: List[VersionCreationTrigger]
+
+    model_config = ConfigDict(
+        alias_generator=to_camel, populate_by_name=True, protected_namespaces=()
+    )
+
+
+class AutomationStatus(str, Enum):
+    """Set the status of the automation."""
+
+    INITIALIZING = "INITIALIZING"
+    RUNNING = "RUNNING"
+    FAILED = "FAILED"
+    SUCCEEDED = "SUCCEEDED"
+    EXCEPTION = "EXCEPTION"
+
+
+class ObjectResultLevel(str, Enum):
+    """Possible status message levels for object reports."""
+
+    SUCCESS = "SUCCESS"
+    INFO = "INFO"
+    WARNING = "WARNING"
+    ERROR = "ERROR"
+
+
+class ResultCase(AutomateBase):
+    """A result case."""
+
+    category: str
+    level: ObjectResultLevel
+    object_app_ids: Dict[str, Optional[str]]
+    message: Optional[str]
+    metadata: Optional[Dict[str, Any]]
+    visual_overrides: Optional[Dict[str, Any]]
+
+
+class AutomationResult(AutomateBase):
+    """Schema accepted by the Speckle server as a result for an automation run."""
+
+    elapsed: float = 0
+    result_view: Optional[str] = None
+    result_versions: List[str] = Field(default_factory=list)
+    blobs: List[str] = Field(default_factory=list)
+    run_status: AutomationStatus = AutomationStatus.RUNNING
+    status_message: Optional[str] = None
+    object_results: list[ResultCase] = Field(default_factory=list)

src/specklepy/__init__.py

@@ -0,0 +1,3 @@
+#  from specklepy import objects
+
+# __all__ = ["objects"]

src/specklepy/api/client.py

@@ -0,0 +1,154 @@
+import contextlib
+
+from specklepy.api.credentials import Account
+from specklepy.api.resources import (
+    ActiveUserResource,
+    ModelResource,
+    OtherUserResource,
+    ProjectInviteResource,
+    ProjectResource,
+    ServerResource,
+    SubscriptionResource,
+    VersionResource,
+    WorkspaceResource,
+)
+from specklepy.core.api.client import SpeckleClient as CoreSpeckleClient
+from specklepy.logging import metrics
+
+
+class SpeckleClient(CoreSpeckleClient):
+    """
+    The `SpeckleClient` is your entry point for interacting with
+    your Speckle Server's GraphQL API.
+    You'll need to have access to a server to use it,
+    or you can use our public server `app.speckle.systems`.
+
+    To authenticate the client, you'll need to have downloaded
+    the [Speckle Manager](https://speckle.guide/#speckle-manager)
+    and added your account.
+
+    ```py
+    from specklepy.api.client import SpeckleClient
+    from specklepy.core.api.inputs.project_inputs import ProjectCreateInput
+    from specklepy.api.credentials import get_default_account
+
+    # initialise the client
+    client = SpeckleClient(host="app.speckle.systems") # or whatever your host is
+    # client = SpeckleClient(host="localhost:3000", use_ssl=False) or use local server
+
+    # authenticate the client with an account
+    # (account has been added in Speckle Manager)
+    account = get_default_account()
+    client.authenticate_with_account(account)
+
+    # create a new project
+    input = ProjectCreateInput(name="a shiny new project")
+    project = self.project.create(input)
+
+    # or, use a project id to get an existing project from the server
+    new_stream = client.project.get("abcdefghij")
+    ```
+    """
+
+    DEFAULT_HOST = "app.speckle.systems"
+    USE_SSL = True
+
+    def __init__(
+        self,
+        host: str = DEFAULT_HOST,
+        use_ssl: bool = USE_SSL,
+        verify_certificate: bool = True,
+    ) -> None:
+        super().__init__(
+            host=host,
+            use_ssl=use_ssl,
+            verify_certificate=verify_certificate,
+        )
+        self.account = Account()
+
+    def _init_resources(self) -> None:
+        self.server = ServerResource(
+            account=self.account, basepath=self.url, client=self.httpclient
+        )
+
+        server_version = None
+
+        with contextlib.suppress(Exception):
+            server_version = self.server.version()
+
+        self.other_user = OtherUserResource(
+            account=self.account,
+            basepath=self.url,
+            client=self.httpclient,
+            server_version=server_version,
+        )
+        self.active_user = ActiveUserResource(
+            account=self.account,
+            basepath=self.url,
+            client=self.httpclient,
+            server_version=server_version,
+        )
+        self.project = ProjectResource(
+            account=self.account,
+            basepath=self.url,
+            client=self.httpclient,
+            server_version=server_version,
+        )
+        self.project_invite = ProjectInviteResource(
+            account=self.account,
+            basepath=self.url,
+            client=self.httpclient,
+            server_version=server_version,
+        )
+        self.model = ModelResource(
+            account=self.account,
+            basepath=self.url,
+            client=self.httpclient,
+            server_version=server_version,
+        )
+        self.version = VersionResource(
+            account=self.account,
+            basepath=self.url,
+            client=self.httpclient,
+            server_version=server_version,
+        )
+        self.workspace = WorkspaceResource(
+            account=self.account,
+            basepath=self.url,
+            client=self.httpclient,
+            server_version=server_version,
+        )
+        self.subscription = SubscriptionResource(
+            account=self.account,
+            basepath=self.ws_url,
+            client=self.wsclient,
+            # todo: why doesn't this take a server version
+        )
+
+    def authenticate_with_token(self, token: str) -> None:
+        """
+        Authenticate the client using a personal access token.
+        The token is saved in the client object and a synchronous GraphQL
+        entrypoint is created
+
+        Arguments:
+            token {str} -- an api token
+        """
+        metrics.track(
+            metrics.SDK, self.account, {"name": "Client Authenticate With Token"}
+        )
+        return super().authenticate_with_token(token)
+
+    def authenticate_with_account(self, account: Account) -> None:
+        """Authenticate the client using an Account object
+        The account is saved in the client object and a synchronous GraphQL
+        entrypoint is created
+
+        Arguments:
+            account {Account} -- the account object which can be found with
+            `get_default_account` or `get_local_accounts`
+        """
+        metrics.track(
+            metrics.SDK, self.account, {"name": "Client Authenticate With Account"}
+        )
+        return super().authenticate_with_account(account)

src/specklepy/api/credentials.py

@@ -0,0 +1,76 @@
+from typing import List, Optional
+
+# following imports seem to be unnecessary, but they need to stay
+# to not break the scripts using these functions as non-core
+from specklepy.core.api.credentials import (  # noqa: F401
+    Account,
+    StreamWrapper,  # noqa: F401
+    UserInfo,
+)
+from specklepy.core.api.credentials import (
+    get_account_from_token as core_get_account_from_token,
+)
+from specklepy.core.api.credentials import get_local_accounts as core_get_local_accounts
+from specklepy.logging import metrics
+
+
+def get_local_accounts(base_path: Optional[str] = None) -> List[Account]:
+    """Gets all the accounts present in this environment
+
+    Arguments:
+        base_path {str} -- custom base path if you are not using the system default
+
+    Returns:
+        List[Account] -- list of all local accounts or an empty list if
+        no accounts were found
+    """
+    accounts = core_get_local_accounts(base_path)
+
+    metrics.track(
+        metrics.SDK,
+        next(
+            (acc for acc in accounts if acc.isDefault),
+            accounts[0] if accounts else None,
+        ),
+        {"name": "Get Local Accounts"},
+    )
+
+    return accounts
+
+
+def get_default_account(base_path: Optional[str] = None) -> Optional[Account]:
+    """
+    Gets this environment's default account if any. If there is no default,
+    the first found will be returned and set as default.
+    Arguments:
+        base_path {str} -- custom base path if you are not using the system default
+
+    Returns:
+        Account -- the default account or None if no local accounts were found
+    """
+    accounts = core_get_local_accounts(base_path=base_path)
+    if not accounts:
+        return None
+
+    default = next((acc for acc in accounts if acc.isDefault), None)
+    if not default:
+        default = accounts[0]
+        default.isDefault = True
+    metrics.initialise_tracker(default)
+
+    return default
+
+
+def get_account_from_token(token: str, server_url: str = None) -> Account:
+    """Gets the local account for the token if it exists
+    Arguments:
+        token {str} -- the api token
+
+    Returns:
+        Account -- the local account with this token or a shell account containing
+        just the token and url if no local account is found
+    """
+    account = core_get_account_from_token(token, server_url)
+
+    metrics.track(metrics.SDK, account, {"name": "Get Account From Token"})
+    return account

src/specklepy/api/host_applications.py

@@ -0,0 +1,74 @@
+from specklepy.core.api.host_applications import (
+    ARCGIS,
+    ARCHICAD,
+    AUTOCAD,
+    BLENDER,
+    CIVIL,
+    CSIBRIDGE,
+    DXF,
+    DYNAMO,
+    ETABS,
+    EXCEL,
+    GRASSHOPPER,
+    GSA,
+    MICROSTATION,
+    NET,
+    OPENBUILDINGS,
+    OPENRAIL,
+    OPENROADS,
+    OTHER,
+    POWERBI,
+    PYTHON,
+    QGIS,
+    REVIT,
+    RHINO,
+    SAFE,
+    SAP2000,
+    SKETCHUP,
+    TEKLASTRUCTURES,
+    TOPSOLID,
+    UNITY,
+    UNREAL,
+    HostApplication,
+    HostAppVersion,
+    _app_name_host_app_mapping,
+    get_host_app_from_string,
+)
+
+# re-exporting stuff from the moved api module
+__all__ = [
+    "ARCGIS",
+    "ARCHICAD",
+    "AUTOCAD",
+    "BLENDER",
+    "CIVIL",
+    "CSIBRIDGE",
+    "DXF",
+    "DYNAMO",
+    "ETABS",
+    "EXCEL",
+    "GRASSHOPPER",
+    "GSA",
+    "MICROSTATION",
+    "NET",
+    "OPENBUILDINGS",
+    "OPENRAIL",
+    "OPENROADS",
+    "OTHER",
+    "POWERBI",
+    "PYTHON",
+    "QGIS",
+    "REVIT",
+    "RHINO",
+    "SAFE",
+    "SAP2000",
+    "SKETCHUP",
+    "TEKLASTRUCTURES",
+    "TOPSOLID",
+    "UNITY",
+    "UNREAL",
+    "HostApplication",
+    "HostAppVersion",
+    "_app_name_host_app_mapping",
+    "get_host_app_from_string",
+]

src/specklepy/api/models/__init__.py

@@ -0,0 +1,15 @@
+# following imports seem to be unnecessary, but they need to stay
+# to not break the scripts using these functions as non-core
+from specklepy.core.api.models import (
+    LimitedUser,
+    PendingStreamCollaborator,
+    ServerInfo,
+    User,
+)
+
+__all__ = [
+    "LimitedUser",
+    "PendingStreamCollaborator",
+    "ServerInfo",
+    "User",
+]

src/specklepy/api/operations.py

@@ -0,0 +1,101 @@
+from typing import List, Optional
+
+from specklepy.core.api.operations import deserialize as core_deserialize
+from specklepy.core.api.operations import receive as _untracked_receive
+from specklepy.core.api.operations import send as core_send
+from specklepy.core.api.operations import serialize as core_serialize
+from specklepy.logging import metrics
+from specklepy.objects.base import Base
+from specklepy.transports.abstract_transport import AbstractTransport
+
+
+def send(
+    base: Base,
+    transports: Optional[List[AbstractTransport]] = None,
+    use_default_cache: bool = True,
+):
+    """Sends an object via the provided transports. Defaults to the local cache.
+
+    Arguments:
+        obj {Base} -- the object you want to send
+        transports {list} -- where you want to send them
+        use_default_cache {bool} -- toggle for the default cache.
+        If set to false, it will only send to the provided transports
+
+    Returns:
+        str -- the object id of the sent object
+    """
+    if transports is None:
+        metrics.track(metrics.SEND)
+    else:
+        metrics.track(metrics.SEND, getattr(transports[0], "account", None))
+
+    return core_send(base, transports, use_default_cache)
+
+
+def receive(
+    obj_id: str,
+    remote_transport: Optional[AbstractTransport] = None,
+    local_transport: Optional[AbstractTransport] = None,
+) -> Base:
+    """Receives an object from a transport.
+
+    Arguments:
+        obj_id {str} -- the id of the object to receive
+        remote_transport {Transport} -- the transport to receive from
+        local_transport {Transport} -- the local cache to check for existing objects
+                                       (defaults to `SQLiteTransport`)
+
+    Returns:
+        Base -- the base object
+    """
+    metrics.track(metrics.RECEIVE, getattr(remote_transport, "account", None))
+    return _untracked_receive(obj_id, remote_transport, local_transport)
+
+
+def serialize(
+    base: Base, write_transports: List[AbstractTransport] | None = None
+) -> str:
+    """
+    Serialize a base object. If no write transports are provided,
+    the object will be serialized
+    without detaching or chunking any of the attributes.
+
+    Arguments:
+        base {Base} -- the object to serialize
+        write_transports {List[AbstractTransport]}
+        -- optional: the transports to write to
+
+    Returns:
+        str -- the serialized object
+    """
+    if not write_transports:
+        write_transports = []
+    metrics.track(metrics.SDK, custom_props={"name": "Serialize"})
+    return core_serialize(base, write_transports)
+
+
+def deserialize(
+    obj_string: str, read_transport: Optional[AbstractTransport] = None
+) -> Base:
+    """
+    Deserialize a string object into a Base object.
+
+    If the object contains referenced child objects that are not stored in the local db,
+    a read transport needs to be provided in order to recompose
+    the base with the children objects.
+
+    Arguments:
+        obj_string {str} -- the string object to deserialize
+        read_transport {AbstractTransport}
+            -- the transport to fetch children objects from
+                (defaults to SQLiteTransport)
+
+    Returns:
+        Base -- the deserialized object
+    """
+    metrics.track(metrics.SDK, custom_props={"name": "Deserialize"})
+    return core_deserialize(obj_string, read_transport)
+
+
+__all__ = ["receive", "send", "serialize", "deserialize"]

src/specklepy/api/resource.py

@@ -0,0 +1,24 @@
+from typing import Any, Optional, Tuple
+
+from gql.client import Client
+
+from specklepy.api.credentials import Account
+from specklepy.core.api.resource import ResourceBase as CoreResourceBase
+
+
+class ResourceBase(CoreResourceBase):
+    def __init__(
+        self,
+        account: Account,
+        basepath: str,
+        client: Client,
+        name: str,
+        server_version: Optional[Tuple[Any, ...]] = None,
+    ) -> None:
+        super().__init__(
+            account=account,
+            basepath=basepath,
+            client=client,
+            name=name,
+            server_version=server_version,
+        )

src/specklepy/api/resources/__init__.py

@@ -0,0 +1,23 @@
+from specklepy.api.resources.current.active_user_resource import ActiveUserResource
+from specklepy.api.resources.current.model_resource import ModelResource
+from specklepy.api.resources.current.other_user_resource import OtherUserResource
+from specklepy.api.resources.current.project_invite_resource import (
+    ProjectInviteResource,
+)
+from specklepy.api.resources.current.project_resource import ProjectResource
+from specklepy.api.resources.current.server_resource import ServerResource
+from specklepy.api.resources.current.subscription_resource import SubscriptionResource
+from specklepy.api.resources.current.version_resource import VersionResource
+from specklepy.api.resources.current.workspace_resource import WorkspaceResource
+
+__all__ = [
+    "ActiveUserResource",
+    "ModelResource",
+    "OtherUserResource",
+    "ProjectInviteResource",
+    "ProjectResource",
+    "ServerResource",
+    "SubscriptionResource",
+    "VersionResource",
+    "WorkspaceResource",
+]

src/specklepy/api/resources/current/active_user_resource.py

@@ -0,0 +1,101 @@
+from typing import List, Optional
+
+from specklepy.core.api.inputs.user_inputs import (
+    UserProjectsFilter,
+    UserUpdateInput,
+    UserWorkspacesFilter,
+)
+from specklepy.core.api.models import (
+    PendingStreamCollaborator,
+    Project,
+    ResourceCollection,
+    User,
+)
+from specklepy.core.api.models.current import (
+    PermissionCheckResult,
+    ProjectWithPermissions,
+    Workspace,
+)
+from specklepy.core.api.resources import ActiveUserResource as CoreResource
+from specklepy.logging import metrics
+
+
+class ActiveUserResource(CoreResource):
+    """API Access class for users. This class provides methods to get and update
+    the user profile, fetch user activity, and manage pending stream invitations."""
+
+    def __init__(self, account, basepath, client, server_version) -> None:
+        super().__init__(
+            account=account,
+            basepath=basepath,
+            client=client,
+            server_version=server_version,
+        )
+        self.schema = User
+
+    def get(self) -> Optional[User]:
+        metrics.track(metrics.SDK, self.account, {"name": "Active User Get"})
+        return super().get()
+
+    def update(
+        self,
+        input: UserUpdateInput,
+    ) -> User:
+        metrics.track(metrics.SDK, self.account, {"name": "Active User Update"})
+
+        return super().update(input=input)
+
+    def get_projects(
+        self,
+        *,
+        limit: int = 25,
+        cursor: Optional[str] = None,
+        filter: Optional[UserProjectsFilter] = None,
+    ) -> ResourceCollection[Project]:
+        metrics.track(metrics.SDK, self.account, {"name": "Active User Get Projects"})
+        return super().get_projects(limit=limit, cursor=cursor, filter=filter)
+
+    def get_projects_with_permissions(
+        self,
+        *,
+        limit: int = 25,
+        cursor: Optional[str] = None,
+        filter: Optional[UserProjectsFilter] = None,
+    ) -> ResourceCollection[ProjectWithPermissions]:
+        metrics.track(
+            metrics.SDK,
+            self.account,
+            {"name": "Active User Get Projects With Permissions"},
+        )
+        return super().get_projects_with_permissions(
+            limit=limit, cursor=cursor, filter=filter
+        )
+
+    def get_project_invites(self) -> List[PendingStreamCollaborator]:
+        metrics.track(
+            metrics.SDK, self.account, {"name": "Active User Get Project Invites"}
+        )
+        return super().get_project_invites()
+
+    def can_create_personal_projects(self) -> PermissionCheckResult:
+        metrics.track(
+            metrics.SDK,
+            self.account,
+            {"name": "Active User Can Create Personal Projects Check"},
+        )
+        return super().can_create_personal_projects()
+
+    def get_workspaces(
+        self,
+        limit: int = 25,
+        cursor: Optional[str] = None,
+        filter: Optional[UserWorkspacesFilter] = None,
+    ) -> ResourceCollection[Workspace]:
+        metrics.track(metrics.SDK, self.account, {"name": "Active User Get Workspaces"})
+        return super().get_workspaces(limit, cursor, filter)
+
+    def get_active_workspace(self) -> Optional[Workspace]:
+        metrics.track(
+            metrics.SDK, self.account, {"name": "Active User Get Active Workspace"}
+        )
+        return super().get_active_workspace()

src/specklepy/api/resources/current/model_resource.py

@@ -0,0 +1,74 @@
+from typing import Optional
+
+from specklepy.core.api.inputs.model_inputs import (
+    CreateModelInput,
+    DeleteModelInput,
+    ModelVersionsFilter,
+    UpdateModelInput,
+)
+from specklepy.core.api.inputs.project_inputs import ProjectModelsFilter
+from specklepy.core.api.models import Model, ModelWithVersions, ResourceCollection
+from specklepy.core.api.resources import ModelResource as CoreResource
+from specklepy.logging import metrics
+
+
+class ModelResource(CoreResource):
+    """API Access class for models"""
+
+    def __init__(self, account, basepath, client, server_version) -> None:
+        super().__init__(
+            account=account,
+            basepath=basepath,
+            client=client,
+            server_version=server_version,
+        )
+
+    def get(self, model_id: str, project_id: str) -> Model:
+        metrics.track(metrics.SDK, self.account, {"name": "Model Get"})
+        return super().get(model_id, project_id)
+
+    def get_with_versions(
+        self,
+        model_id: str,
+        project_id: str,
+        *,
+        versions_limit: int = 25,
+        versions_cursor: Optional[str] = None,
+        versions_filter: Optional[ModelVersionsFilter] = None,
+    ) -> ModelWithVersions:
+        metrics.track(metrics.SDK, self.account, {"name": "Model Get With Versions"})
+        return super().get_with_versions(
+            model_id,
+            project_id,
+            versions_limit=versions_limit,
+            versions_cursor=versions_cursor,
+            versions_filter=versions_filter,
+        )
+
+    def get_models(
+        self,
+        project_id: str,
+        *,
+        models_limit: int = 25,
+        models_cursor: Optional[str] = None,
+        models_filter: Optional[ProjectModelsFilter] = None,
+    ) -> ResourceCollection[Model]:
+        metrics.track(metrics.SDK, self.account, {"name": "Model Get Models"})
+        return super().get_models(
+            project_id,
+            models_limit=models_limit,
+            models_cursor=models_cursor,
+            models_filter=models_filter,
+        )
+
+    def create(self, input: CreateModelInput) -> Model:
+        metrics.track(metrics.SDK, self.account, {"name": "Model Create"})
+        return super().create(input)
+
+    def delete(self, input: DeleteModelInput) -> bool:
+        metrics.track(metrics.SDK, self.account, {"name": "Model Delete"})
+        return super().delete(input)
+
+    def update(self, input: UpdateModelInput) -> Model:
+        metrics.track(metrics.SDK, self.account, {"name": "Model Update"})
+        return super().update(input)

src/specklepy/api/resources/current/other_user_resource.py

@@ -0,0 +1,45 @@
+from typing import Optional
+
+from specklepy.core.api.models import (
+    LimitedUser,
+    UserSearchResultCollection,
+)
+from specklepy.core.api.resources import OtherUserResource as CoreResource
+from specklepy.logging import metrics
+
+
+class OtherUserResource(CoreResource):
+    """
+    Provides API access to other users' profiles and activities on the platform.
+    This class enables fetching limited information about users,
+    searching for users by name or email,
+    and accessing user activity logs with appropriate privacy
+    and access control measures in place.
+    """
+
+    def __init__(self, account, basepath, client, server_version) -> None:
+        super().__init__(
+            account=account,
+            basepath=basepath,
+            client=client,
+            server_version=(server_version,),
+        )
+        self.schema = LimitedUser
+
+    def get(self, id: str) -> Optional[LimitedUser]:
+        metrics.track(metrics.SDK, self.account, {"name": "Other User Get"})
+        return super().get(id)
+
+    def user_search(
+        self,
+        query: str,
+        *,
+        limit: int = 25,
+        cursor: Optional[str] = None,
+        archived: bool = False,
+        emailOnly: bool = False,
+    ) -> UserSearchResultCollection:
+        metrics.track(metrics.SDK, self.account, {"name": "Other User Search"})
+        return super().user_search(
+            query, limit=limit, cursor=cursor, archived=archived, emailOnly=emailOnly
+        )

src/specklepy/api/resources/current/project_invite_resource.py

@@ -0,0 +1,54 @@
+from typing import Any, Optional, Tuple
+
+from gql import Client
+
+from specklepy.core.api.credentials import Account
+from specklepy.core.api.inputs.project_inputs import (
+    ProjectInviteCreateInput,
+    ProjectInviteUseInput,
+)
+from specklepy.core.api.models import PendingStreamCollaborator, ProjectWithTeam
+from specklepy.core.api.resources import ProjectInviteResource as CoreResource
+from specklepy.logging import metrics
+
+
+class ProjectInviteResource(CoreResource):
+    """API Access class for project invites"""
+
+    def __init__(
+        self,
+        account: Account,
+        basepath: str,
+        client: Client,
+        server_version: Optional[Tuple[Any, ...]],
+    ) -> None:
+        super().__init__(
+            account=account,
+            basepath=basepath,
+            client=client,
+            server_version=server_version,
+        )
+
+    def create(
+        self, project_id: str, input: ProjectInviteCreateInput
+    ) -> ProjectWithTeam:
+        metrics.track(metrics.SDK, self.account, {"name": "Project Invite Create"})
+        return super().create(project_id, input)
+
+    def use(self, input: ProjectInviteUseInput) -> bool:
+        metrics.track(metrics.SDK, self.account, {"name": "Project Invite Use"})
+        return super().use(input)
+
+    def get(
+        self, project_id: str, token: Optional[str]
+    ) -> Optional[PendingStreamCollaborator]:
+        metrics.track(metrics.SDK, self.account, {"name": "Project Invite Get"})
+        return super().get(project_id, token)
+
+    def cancel(
+        self,
+        project_id: str,
+        invite_id: str,
+    ) -> ProjectWithTeam:
+        metrics.track(metrics.SDK, self.account, {"name": "Project Invite Cancel"})
+        return super().cancel(project_id, invite_id)

src/specklepy/api/resources/current/project_resource.py

@@ -0,0 +1,79 @@
+from typing import Optional
+
+from specklepy.core.api.inputs.project_inputs import (
+    ProjectCreateInput,
+    ProjectModelsFilter,
+    ProjectUpdateInput,
+    ProjectUpdateRoleInput,
+    WorkspaceProjectCreateInput,
+)
+from specklepy.core.api.models import (
+    Project,
+    ProjectWithModels,
+    ProjectWithTeam,
+)
+from specklepy.core.api.models.current import ProjectPermissionChecks
+from specklepy.core.api.resources import ProjectResource as CoreResource
+from specklepy.logging import metrics
+
+
+class ProjectResource(CoreResource):
+    """API Access class for projects"""
+
+    def __init__(self, account, basepath, client, server_version) -> None:
+        super().__init__(
+            account=account,
+            basepath=basepath,
+            client=client,
+            server_version=server_version,
+        )
+
+    def get(self, project_id: str) -> Project:
+        metrics.track(metrics.SDK, self.account, {"name": "Project Get "})
+        return super().get(project_id)
+
+    def get_permissions(self, project_id: str) -> ProjectPermissionChecks:
+        metrics.track(
+            metrics.SDK, self.account, {"name": "Project Project Permissions "}
+        )
+        return super().get_permissions(project_id)
+
+    def get_with_models(
+        self,
+        project_id: str,
+        *,
+        models_limit: int = 25,
+        models_cursor: Optional[str] = None,
+        models_filter: Optional[ProjectModelsFilter] = None,
+    ) -> ProjectWithModels:
+        metrics.track(metrics.SDK, self.account, {"name": "Project Get With Models"})
+        return super().get_with_models(
+            project_id,
+            models_limit=models_limit,
+            models_cursor=models_cursor,
+            models_filter=models_filter,
+        )
+
+    def get_with_team(self, project_id: str) -> ProjectWithTeam:
+        metrics.track(metrics.SDK, self.account, {"name": "Project Get With Team"})
+        return super().get_with_team(project_id)
+
+    def create(self, input: ProjectCreateInput) -> Project:
+        metrics.track(metrics.SDK, self.account, {"name": "Project Create"})
+        return super().create(input)
+
+    def create_in_workspace(self, input: WorkspaceProjectCreateInput) -> Project:
+        metrics.track(metrics.SDK, self.account, {"name": "Workspace Project Create"})
+        return super().create_in_workspace(input)
+
+    def update(self, input: ProjectUpdateInput) -> Project:
+        metrics.track(metrics.SDK, self.account, {"name": "Project Update"})
+        return super().update(input)
+
+    def delete(self, project_id: str) -> bool:
+        metrics.track(metrics.SDK, self.account, {"name": "Project Delete"})
+        return super().delete(project_id)
+
+    def update_role(self, input: ProjectUpdateRoleInput) -> ProjectWithTeam:
+        metrics.track(metrics.SDK, self.account, {"name": "Project Update Role"})
+        return super().update_role(input)

src/specklepy/api/resources/current/server_resource.py

@@ -0,0 +1,71 @@
+from typing import Any, Dict, List, Tuple
+
+from specklepy.api.models import ServerInfo
+from specklepy.core.api.resources import ServerResource as CoreResource
+from specklepy.logging import metrics
+
+
+class ServerResource(CoreResource):
+    """API Access class for the server"""
+
+    def __init__(self, account, basepath, client) -> None:
+        super().__init__(
+            account=account,
+            basepath=basepath,
+            client=client,
+        )
+
+    def get(self) -> ServerInfo:
+        """Get the server info
+
+        Returns:
+            dict -- the server info in dictionary form
+        """
+        metrics.track(metrics.SDK, self.account, {"name": "Server Get"})
+        return super().get()
+
+    def version(self) -> Tuple[Any, ...]:
+        """Get the server version
+
+        Returns:
+            the server version in the format (major, minor, patch, (tag, build))
+            eg (2, 6, 3) for a stable build and (2, 6, 4, 'alpha', 4711) for alpha
+        """
+        # not tracking as it will be called along with other
+        # mutations / queries as a check
+        return super().version()
+
+    def apps(self) -> Dict:
+        """Get the apps registered on the server
+
+        Returns:
+            dict -- a dictionary of apps registered on the server
+        """
+        metrics.track(metrics.SDK, self.account, {"name": "Server Apps"})
+        return super().apps()
+
+    def create_token(self, name: str, scopes: List[str], lifespan: int) -> str:
+        """Create a personal API token
+
+        Arguments:
+            scopes {List[str]} -- the scopes to grant with this token
+            name {str} -- a name for your new token
+            lifespan {int} -- duration before the token expires
+
+        Returns:
+            str -- the new API token. note: this is the only time you'll see the token!
+        """
+        metrics.track(metrics.SDK, self.account, {"name": "Server Create Token"})
+        return super().create_token(name, scopes, lifespan)
+
+    def revoke_token(self, token: str) -> bool:
+        """Revokes (deletes) a personal API token
+
+        Arguments:
+            token {str} -- the token to revoke (delete)
+
+        Returns:
+            bool -- True if the token was successfully deleted
+        """
+        metrics.track(metrics.SDK, self.account, {"name": "Server Revoke Token"})
+        return super().revoke_token(token)

src/specklepy/api/resources/current/subscription_resource.py

@@ -0,0 +1,64 @@
+from typing import Callable, Optional, Sequence
+
+from pydantic import BaseModel
+from typing_extensions import TypeVar
+
+from specklepy.core.api.models import (
+    ProjectModelsUpdatedMessage,
+    ProjectUpdatedMessage,
+    ProjectVersionsUpdatedMessage,
+    UserProjectsUpdatedMessage,
+)
+from specklepy.core.api.resources import SubscriptionResource as CoreResource
+from specklepy.logging import metrics
+
+TEventArgs = TypeVar("TEventArgs", bound=BaseModel)
+
+
+class SubscriptionResource(CoreResource):
+    def __init__(self, account, basepath, client) -> None:
+        super().__init__(
+            account=account,
+            basepath=basepath,
+            client=client,
+        )
+
+    async def user_projects_updated(
+        self, callback: Callable[[UserProjectsUpdatedMessage], None]
+    ) -> None:
+        metrics.track(
+            metrics.SDK, self.account, {"name": "Subscription Project Models Updated"}
+        )
+        return await super().user_projects_updated(callback)
+
+    async def project_models_updated(
+        self,
+        callback: Callable[[ProjectModelsUpdatedMessage], None],
+        id: str,
+        *,
+        model_ids: Optional[Sequence[str]] = None,
+    ) -> None:
+        metrics.track(
+            metrics.SDK, self.account, {"name": "Subscription Project Models Updated"}
+        )
+        return await super().project_models_updated(callback, id, model_ids=model_ids)
+
+    async def project_updated(
+        self,
+        callback: Callable[[ProjectUpdatedMessage], None],
+        id: str,
+    ) -> None:
+        metrics.track(
+            metrics.SDK, self.account, {"name": "Subscription Project Updated"}
+        )
+        return await super().project_updated(callback, id)
+
+    async def project_versions_updated(
+        self,
+        callback: Callable[[ProjectVersionsUpdatedMessage], None],
+        id: str,
+    ) -> None:
+        metrics.track(
+            metrics.SDK, self.account, {"name": "Subscription Project Versions Updated"}
+        )
+        return await super().project_versions_updated(callback, id)

src/specklepy/api/resources/current/version_resource.py

@@ -0,0 +1,63 @@
+from typing import Optional
+
+from specklepy.core.api.inputs.model_inputs import ModelVersionsFilter
+from specklepy.core.api.inputs.version_inputs import (
+    CreateVersionInput,
+    DeleteVersionsInput,
+    MarkReceivedVersionInput,
+    MoveVersionsInput,
+    UpdateVersionInput,
+)
+from specklepy.core.api.models import ResourceCollection, Version
+from specklepy.core.api.resources import VersionResource as CoreResource
+from specklepy.logging import metrics
+
+
+class VersionResource(CoreResource):
+    """API Access class for model versions"""
+
+    def __init__(self, account, basepath, client, server_version) -> None:
+        super().__init__(
+            account=account,
+            basepath=basepath,
+            client=client,
+            server_version=server_version,
+        )
+
+    def get(self, version_id: str, project_id: str) -> Version:
+        metrics.track(metrics.SDK, self.account, {"name": "Version Get"})
+        return super().get(version_id, project_id)
+
+    def get_versions(
+        self,
+        model_id: str,
+        project_id: str,
+        *,
+        limit: int = 25,
+        cursor: Optional[str] = None,
+        filter: Optional[ModelVersionsFilter] = None,
+    ) -> ResourceCollection[Version]:
+        metrics.track(metrics.SDK, self.account, {"name": "Version Get Versions"})
+        return super().get_versions(
+            model_id, project_id, limit=limit, cursor=cursor, filter=filter
+        )
+
+    def create(self, input: CreateVersionInput) -> Version:
+        metrics.track(metrics.SDK, self.account, {"name": "Version Create"})
+        return super().create(input)
+
+    def update(self, input: UpdateVersionInput) -> Version:
+        metrics.track(metrics.SDK, self.account, {"name": "Version Update"})
+        return super().update(input)
+
+    def move_to_model(self, input: MoveVersionsInput) -> str:
+        metrics.track(metrics.SDK, self.account, {"name": "Version Move To Model"})
+        return super().move_to_model(input)
+
+    def delete(self, input: DeleteVersionsInput) -> bool:
+        metrics.track(metrics.SDK, self.account, {"name": "Version Delete"})
+        return super().delete(input)
+
+    def received(self, input: MarkReceivedVersionInput) -> bool:
+        metrics.track(metrics.SDK, self.account, {"name": "Version Received"})
+        return super().received(input)

src/specklepy/api/resources/current/workspace_resource.py

@@ -0,0 +1,53 @@
+from typing import Optional
+
+from specklepy.core.api.inputs.project_inputs import WorksaceProjectsFilter
+from specklepy.core.api.models.current import (
+    Project,
+    ProjectWithPermissions,
+    ResourceCollection,
+    Workspace,
+)
+from specklepy.core.api.resources import WorkspaceResource as CoreResource
+from specklepy.logging import metrics
+
+
+class WorkspaceResource(CoreResource):
+    """API Access class for workspace"""
+
+    def __init__(self, account, basepath, client, server_version) -> None:
+        super().__init__(
+            account=account,
+            basepath=basepath,
+            client=client,
+            server_version=server_version,
+        )
+
+    def get(self, workspace_id: str) -> Workspace:
+        metrics.track(metrics.SDK, self.account, {"name": "Workspace Get"})
+        return super().get(workspace_id)
+
+    def get_projects(
+        self,
+        workspace_id: str,
+        limit: int = 25,
+        cursor: Optional[str] = None,
+        filter: Optional[WorksaceProjectsFilter] = None,
+    ) -> ResourceCollection[Project]:
+        metrics.track(metrics.SDK, self.account, {"name": "Workspace Get Projects"})
+        return super().get_projects(workspace_id, limit, cursor, filter)
+
+    def get_projects_with_permissions(
+        self,
+        workspace_id: str,
+        limit: int = 25,
+        cursor: Optional[str] = None,
+        filter: Optional[WorksaceProjectsFilter] = None,
+    ) -> ResourceCollection[ProjectWithPermissions]:
+        metrics.track(
+            metrics.SDK,
+            self.account,
+            {"name": "Workspace Get Projects With Permissions"},
+        )
+        return super().get_projects_with_permissions(
+            workspace_id, limit, cursor, filter
+        )

src/specklepy/api/wrapper.py

@@ -0,0 +1,88 @@
+from specklepy.api.client import SpeckleClient
+from specklepy.api.credentials import Account
+from specklepy.core.api.wrapper import StreamWrapper as CoreStreamWrapper
+from specklepy.logging import metrics
+from specklepy.transports.server.server import ServerTransport
+
+
+class StreamWrapper(CoreStreamWrapper):
+    """
+    The `StreamWrapper` gives you some handy helpers to deal with urls and
+    get authenticated clients and transports.
+
+    Construct a `StreamWrapper` with a URL of a model, version, or object.
+    The corresponding ids will be stored
+    in the wrapper. If you have local accounts on the machine,
+    you can use the `get_account` and `get_client` methods
+    to get a local account for the server. You can also pass a token into `get_client`
+    if you don't have a corresponding
+    local account for the server.
+
+    ```py
+    from specklepy.api.wrapper import StreamWrapper
+
+    # provide a url for a model, version, or object
+    wrapper = StreamWrapper("https://app.speckle.systems/projects/3073b96e86/models/0fe47c9dca@604bea8cc6")
+
+    # get an authenticated SpeckleClient if you have a local account for the server
+    client = wrapper.get_client()
+
+    # get an authenticated ServerTransport if you have a local account for the server
+    transport = wrapper.get_transport()
+    ```
+    """
+
+    stream_url: str = None
+    use_ssl: bool = True
+    host: str = None
+    stream_id: str = None
+    commit_id: str = None
+    object_id: str = None
+    branch_name: str = None
+    _client: SpeckleClient = None
+    _account: Account = None
+
+    def __init__(self, url: str) -> None:
+        super().__init__(url=url)
+
+    def get_account(self, token: str = None) -> Account:
+        """
+        Gets an account object for this server from the local accounts db
+        (added via Speckle Manager or a json file)
+        """
+        metrics.track(metrics.SDK, custom_props={"name": "Stream Wrapper Get Account"})
+        return super().get_account(token)
+
+    def get_client(self, token: str = None) -> SpeckleClient:
+        """
+        Gets an authenticated client for this server.
+        You may provide a token if there aren't any local accounts on this
+        machine. If no account is found and no token is provided,
+        an unauthenticated client is returned.
+
+        Arguments:
+            token {str}
+            -- optional token if no local account is available (defaults to None)
+
+        Returns:
+            SpeckleClient
+            -- authenticated with a corresponding local account or the provided token
+        """
+        metrics.track(metrics.SDK, custom_props={"name": "Stream Wrapper Get Client"})
+        return super().get_client(token)
+
+    def get_transport(self, token: str = None) -> ServerTransport:
+        """
+        Gets a server transport for this stream using an authenticated client.
+        If there is no local account for this
+        server and the client was not authenticated with a token,
+        this will throw an exception.
+
+        Returns:
+            ServerTransport -- constructed for this stream
+            with a pre-authenticated client
+        """
+        metrics.track(
+            metrics.SDK, custom_props={"name": "Stream Wrapper Get Transport"}
+        )
+        return super().get_transport(token)

src/specklepy/core/__init__.py

@@ -0,0 +1,6 @@
+"""
+This is the Core SDK module of `specklepy`.
+
+This module should be kept in sync with the functionalities of our other SDKs especially
+C# Core https://github.com/specklesystems/speckle-sharp/tree/main/Core/Core
+"""

src/specklepy/core/api/client.py

@@ -0,0 +1,237 @@
+import contextlib
+import re
+from typing import Dict
+from warnings import warn
+
+from gql import Client
+from gql.transport.exceptions import TransportServerError
+from gql.transport.requests import RequestsHTTPTransport
+from gql.transport.websockets import WebsocketsTransport
+
+from specklepy.core.api.credentials import Account
+from specklepy.core.api.resources import (
+    ActiveUserResource,
+    ModelResource,
+    OtherUserResource,
+    ProjectInviteResource,
+    ProjectResource,
+    ServerResource,
+    SubscriptionResource,
+    VersionResource,
+    WorkspaceResource,
+)
+from specklepy.logging import metrics
+from specklepy.logging.exceptions import SpeckleException, SpeckleWarning
+
+
+class SpeckleClient:
+    """
+    The `SpeckleClient` is your entry point for interacting with
+    your Speckle Server's GraphQL API.
+    You'll need to have access to a server to use it,
+    or you can use our public server `app.speckle.systems`.
+
+    To authenticate the client, you'll need to have downloaded
+    the [Speckle Manager](https://speckle.guide/#speckle-manager)
+    and added your account.
+
+    ```py
+    from specklepy.api.client import SpeckleClient
+    from specklepy.core.api.inputs.project_inputs import ProjectCreateInput
+    from specklepy.api.credentials import get_default_account
+
+    # initialise the client
+    client = SpeckleClient(host="app.speckle.systems") # or whatever your host is
+    # client = SpeckleClient(host="localhost:3000", use_ssl=False) or use local server
+
+    # authenticate the client with an account
+    # (account has been added in Speckle Manager)
+    account = get_default_account()
+    client.authenticate_with_account(account)
+
+    # create a new project
+    input = ProjectCreateInput(name="a shiny new project")
+    project = self.project.create(input)
+
+    # or, use a project id to get an existing project from the server
+    new_stream = client.project.get("abcdefghij")
+    ```
+    """
+
+    DEFAULT_HOST = "app.speckle.systems"
+    USE_SSL = True
+
+    def __init__(
+        self,
+        host: str = DEFAULT_HOST,
+        use_ssl: bool = USE_SSL,
+        verify_certificate: bool = True,
+        connection_retries: int = 3,
+        connection_timeout: int = 10,
+    ) -> None:
+        ws_protocol = "ws"
+        http_protocol = "http"
+
+        if use_ssl:
+            ws_protocol = "wss"
+            http_protocol = "https"
+
+        # sanitise host input by removing protocol and trailing slash
+        host = re.sub(r"((^\w+:|^)\/\/)|(\/$)", "", host)
+
+        self.url = f"{http_protocol}://{host}"
+        self.graphql = f"{self.url}/graphql"
+        self.ws_url = f"{ws_protocol}://{host}/graphql"
+        self.account = Account()
+        self.verify_certificate = verify_certificate
+        self.connection_retries = connection_retries
+        self.connection_timeout = connection_timeout
+
+        self.httpclient = Client(
+            transport=RequestsHTTPTransport(
+                url=self.graphql,
+                verify=self.verify_certificate,
+                retries=self.connection_retries,
+                timeout=self.connection_timeout,
+            )
+        )
+        self.wsclient = None
+
+        self._init_resources()
+
+        # ? Check compatibility with the server
+        # - i think we can skip this at this point? save a request
+        # try:
+        #     server_info = self.server.get()
+        #     if isinstance(server_info, Exception):
+        #         raise server_info
+        #     if not isinstance(server_info, ServerInfo):
+        #         raise Exception("Couldn't get ServerInfo")
+        # except Exception as ex:
+        #     raise SpeckleException(
+        #         f"{self.url} is not a compatible Speckle Server", ex
+        #     ) from ex
+
+    def __repr__(self):
+        return (
+            f"SpeckleClient( server: {self.url}, authenticated:"
+            f" {self.account.token is not None} )"
+        )
+
+    def authenticate_with_token(self, token: str) -> None:
+        """
+        Authenticate the client using a personal access token.
+        The token is saved in the client object and a synchronous GraphQL
+        entrypoint is created
+
+        Arguments:
+            token {str} -- an api token
+        """
+        self.account = Account.from_token(token, self.url)
+        self._set_up_client()
+
+    def authenticate_with_account(self, account: Account) -> None:
+        """Authenticate the client using an Account object
+        The account is saved in the client object and a synchronous GraphQL
+        entrypoint is created
+
+        Arguments:
+            account {Account} -- the account object which can be found with
+            `get_default_account` or `get_local_accounts`
+        """
+        self.account = account
+        self._set_up_client()
+
+    def _set_up_client(self) -> None:
+        headers = {
+            "Authorization": f"Bearer {self.account.token}",
+            "Content-Type": "application/json",
+            "apollographql-client-name": metrics.HOST_APP,
+            "apollographql-client-version": metrics.HOST_APP_VERSION,
+        }
+        httptransport = RequestsHTTPTransport(
+            url=self.graphql, headers=headers, verify=self.verify_certificate, retries=3
+        )
+        wstransport = WebsocketsTransport(
+            url=self.ws_url,
+            init_payload={"Authorization": f"Bearer {self.account.token}"},
+        )
+        self.httpclient = Client(transport=httptransport)
+        self.wsclient = Client(transport=wstransport)
+
+        self._init_resources()
+
+        try:
+            _ = self.active_user.get()
+        except SpeckleException as ex:
+            if isinstance(ex.exception, TransportServerError):
+                if ex.exception.code == 403:
+                    warn(
+                        SpeckleWarning(
+                            "Possibly invalid token - could not authenticate "
+                            f"Speckle Client for server {self.url}"
+                        ),
+                        stacklevel=2,
+                    )
+                else:
+                    raise ex
+
+    def execute_query(self, query: str) -> Dict:
+        return self.httpclient.execute(query)
+
+    def _init_resources(self) -> None:
+        self.server = ServerResource(
+            account=self.account, basepath=self.url, client=self.httpclient
+        )
+
+        server_version = None
+        with contextlib.suppress(Exception):
+            server_version = self.server.version()
+
+        self.other_user = OtherUserResource(
+            account=self.account,
+            basepath=self.url,
+            client=self.httpclient,
+            server_version=server_version,
+        )
+        self.active_user = ActiveUserResource(
+            account=self.account,
+            basepath=self.url,
+            client=self.httpclient,
+            server_version=server_version,
+        )
+        self.project = ProjectResource(
+            account=self.account,
+            basepath=self.url,
+            client=self.httpclient,
+            server_version=server_version,
+        )
+        self.project_invite = ProjectInviteResource(
+            account=self.account,
+            basepath=self.url,
+            client=self.httpclient,
+            server_version=server_version,
+        )
+        self.model = ModelResource(
+            account=self.account,
+            basepath=self.url,
+            client=self.httpclient,
+            server_version=server_version,
+        )
+        self.version = VersionResource(
+            account=self.account,
+            basepath=self.url,
+            client=self.httpclient,
+            server_version=server_version,
+        )
+        self.workspace = WorkspaceResource(
+            account=self.account,
+            basepath=self.url,
+            client=self.httpclient,
+            server_version=server_version,
+        )
+        self.subscription = SubscriptionResource(
+            account=self.account,
+            basepath=self.ws_url,
+            client=self.wsclient,
+        )

src/specklepy/core/api/connector_versions.py

@@ -0,0 +1,70 @@
+from datetime import datetime
+from typing import List
+
+import httpx
+from pydantic import AliasGenerator, BaseModel, ConfigDict, HttpUrl
+from pydantic.alias_generators import to_pascal
+
+
+class ConnectorFeedBaseModel(BaseModel):
+    """
+    Parent class for all Connector Feed Object Model classes
+    Sets-up a pydantic config to serialize properties using a pascal case alias
+    """
+
+    model_config = ConfigDict(
+        alias_generator=AliasGenerator(
+            validation_alias=to_pascal,
+        ),
+        populate_by_name=True,
+    )
+
+
+class ConnectorVersion(ConnectorFeedBaseModel):
+    number: str
+    url: HttpUrl
+    os: int  # this is an enum, it's properly defined in the old v2 SDK (used by Speckle.Manager.Feed)  # noqa: E501
+    architecture: int  # These are enums, they are properly defined in the old v2 SDK (used by Speckle.Manager.Feed) # noqa: E501
+    date: datetime
+    prerelease: bool
+
+
+class ConnectorVersions(ConnectorFeedBaseModel):
+    versions: List[ConnectorVersion]
+
+
+def get_latest_version(host_app_slug: str, allow_pre_release: bool) -> ConnectorVersion:
+    """
+    Fetches the JSON feed for the given connector slug and
+    Returns the latest version by date - Note, it does not consider semvers!
+
+    Arguments:
+        host_app_slug {str} -- the host app slug to query for
+        allow_pre_release {bool} -- if false, only stable releases will be considered
+    Raises:
+        HTTPStatusError: if http request failed
+        ValidationError: response was not valid json
+        ValueError: The feed contained no connector versions
+    """
+    connector_versions = get_connector_versions(host_app_slug).versions
+    filtered_versions = [
+        v for v in connector_versions if allow_pre_release or not v.prerelease
+    ]
+
+    return max(filtered_versions, key=lambda x: x.date)
+
+
+def get_connector_versions(host_app_slug: str) -> ConnectorVersions:
+    """
+    Fetches the JSON feed for the given slug (v3 feeds only)
+    Raises:
+        HTTPStatusError: if http request failed
+        ValidationError: response was not valid json
+    """
+    url = f"https://releases.speckle.dev/manager2/feeds/{host_app_slug.lower()}-v3.json"
+
+    res = httpx.get(url).raise_for_status()
+
+    feed_data = ConnectorVersions.model_validate_json(res.text)
+
+    return feed_data

src/specklepy/core/api/credentials.py

@@ -0,0 +1,177 @@
+import os
+from pathlib import Path
+from typing import List, Optional
+from urllib.parse import urlparse
+
+from pydantic import BaseModel, Field  # pylint: disable=no-name-in-module
+
+from specklepy.core.api.models import ServerInfo
+from specklepy.core.helpers import speckle_path_provider
+from specklepy.logging.exceptions import SpeckleException
+from specklepy.transports.sqlite import SQLiteTransport
+
+
+class UserInfo(BaseModel):
+    id: Optional[str] = None
+    name: Optional[str] = None
+    email: Optional[str] = None
+    company: Optional[str] = None
+    avatar: Optional[str] = None
+
+
+class Account(BaseModel):
+    isDefault: bool = False
+    token: Optional[str] = None
+    refreshToken: Optional[str] = None
+    serverInfo: ServerInfo = Field(default_factory=ServerInfo)
+    userInfo: UserInfo = Field(default_factory=UserInfo)
+    id: Optional[str] = None
+
+    def __repr__(self) -> str:
+        return (
+            f"Account(email: {self.userInfo.email}, server: {self.serverInfo.url},"
+            f" isDefault: {self.isDefault})"
+        )
+
+    def __str__(self) -> str:
+        return self.__repr__()
+
+    @classmethod
+    def from_token(cls, token: str, server_url: str = None):
+        acct = cls(token=token)
+        acct.serverInfo.url = server_url
+        return acct
+
+
+def get_local_accounts(base_path: Optional[str] = None) -> List[Account]:
+    """Gets all the accounts present in this environment
+
+    Arguments:
+        base_path {str} -- custom base path if you are not using the system default
+
+    Returns:
+        List[Account] -- list of all local accounts or an empty list if
+        no accounts were found
+    """
+    accounts: List[Account] = []
+    try:
+        account_storage = SQLiteTransport(scope="Accounts", base_path=base_path)
+        res = account_storage.get_all_objects()
+        account_storage.close()
+        if res:
+            accounts.extend(Account.model_validate_json(r[1]) for r in res)
+    except SpeckleException:
+        # cannot open SQLiteTransport, probably because of the lack
+        # of disk write permissions
+        pass
+
+    json_acct_files = []
+    json_path = str(speckle_path_provider.accounts_folder_path())
+    try:
+        os.makedirs(json_path, exist_ok=True)
+        json_acct_files.extend(
+            file for file in os.listdir(json_path) if file.endswith(".json")
+        )
+
+    except Exception:
+        # cannot find or get the json account paths
+        pass
+
+    if json_acct_files:
+        try:
+            accounts.extend(
+                Account.model_validate_json(Path(json_path, json_file).read_text())
+                # Account.parse_file(os.path.join(json_path, json_file))
+                for json_file in json_acct_files
+            )
+        except Exception as ex:
+            raise SpeckleException(
+                "Invalid json accounts could not be read. Please fix or remove them.",
+                ex,
+            ) from ex
+
+    return accounts
+
+
+def get_default_account(base_path: Optional[str] = None) -> Optional[Account]:
+    """
+    Gets this environment's default account if any. If there is no default,
+    the first found will be returned and set as default.
+    Arguments:
+        base_path {str} -- custom base path if you are not using the system default
+
+    Returns:
+        Account -- the default account or None if no local accounts were found
+    """
+    accounts = get_local_accounts(base_path=base_path)
+    if not accounts:
+        return None
+
+    default = next((acc for acc in accounts if acc.isDefault), None)
+    if not default:
+        default = accounts[0]
+        default.isDefault = True
+    # metrics.initialise_tracker(default)
+
+    return default
+
+
+def get_account_from_token(token: str, server_url: str = None) -> Account:
+    """Gets the local account for the token if it exists
+    Arguments:
+        token {str} -- the api token
+
+    Returns:
+        Account -- the local account with this token or a shell account containing
+        just the token and url if no local account is found
+    """
+    accounts = get_local_accounts()
+    if not accounts:
+        return Account.from_token(token, server_url)
+
+    acct = next((acc for acc in accounts if acc.token == token), None)
+    if acct:
+        return acct
+
+    if server_url:
+        url = server_url.lower()
+        acct = next(
+            (acc for acc in accounts if url in acc.serverInfo.url.lower()), None
+        )
+        if acct:
+            return acct
+
+    return Account.from_token(token, server_url)
+
+
+def get_accounts_for_server(host: str) -> List[Account]:
+    all_accounts = get_local_accounts()
+    filtered: List[Account] = []
+
+    for acc in all_accounts:
+        moved_from = (
+            acc.serverInfo.migration.moved_from if acc.serverInfo.migration else None
+        )
+
+        if moved_from and host == urlparse(moved_from).netloc:
+            filtered.append(acc)
+
+    for acc in all_accounts:
+        if any([x for x in filtered if x.userInfo.id == acc.userInfo.id]):
+            continue
+
+        if host == urlparse(acc.serverInfo.url).netloc:
+            filtered.append(acc)
+
+    return filtered
+
+
+class StreamWrapper:
+    def __init__(self, url: str = None) -> None:
+        raise SpeckleException(
+            message=(
+                "The StreamWrapper has moved as of v2.6.0! Please import from"
+                " specklepy.api.wrapper"
+            ),
+            exception=DeprecationWarning(),
+        )

src/specklepy/core/api/enums.py

@@ -0,0 +1,32 @@
+from enum import Enum
+
+
+class ProjectVisibility(str, Enum):
+    """Supported project visibility types"""
+
+    PRIVATE = "PRIVATE"
+    PUBLIC = "PUBLIC"
+    UNLISTED = "UNLISTED"
+    WORKSPACE = "WORKSPACE"
+
+
+class UserProjectsUpdatedMessageType(str, Enum):
+    ADDED = "ADDED"
+    REMOVED = "REMOVED"
+
+
+class ProjectModelsUpdatedMessageType(str, Enum):
+    CREATED = "CREATED"
+    DELETED = "DELETED"
+    UPDATED = "UPDATED"
+
+
+class ProjectUpdatedMessageType(str, Enum):
+    DELETED = "DELETED"
+    UPDATED = "UPDATED"
+
+
+class ProjectVersionsUpdatedMessageType(str, Enum):
+    CREATED = "CREATED"
+    DELETED = "DELETED"
+    UPDATED = "UPDATED"

src/specklepy/core/api/host_applications.py

@@ -0,0 +1,116 @@
+from dataclasses import dataclass
+from enum import Enum
+from unicodedata import name
+
+
+class HostAppVersion(Enum):
+    v = "v"
+    v6 = "v6"
+    v7 = "v7"
+    v2019 = "v2019"
+    v2020 = "v2020"
+    v2021 = "v2021"
+    v2022 = "v2022"
+    v2023 = "v2023"
+    v2024 = "v2024"
+    v2025 = "v2025"
+    vSandbox = "vSandbox"
+    vRevit = "vRevit"
+    vRevit2021 = "vRevit2021"
+    vRevit2022 = "vRevit2022"
+    vRevit2023 = "vRevit2023"
+    vRevit2024 = "vRevit2024"
+    vRevit2025 = "vRevit2025"
+    v25 = "v25"
+    v26 = "v26"
+
+    def __repr__(self) -> str:
+        return self.value
+
+    def __str__(self) -> str:
+        return self.value
+
+
+@dataclass
+class HostApplication:
+    name: str
+    slug: str
+
+    def get_version(self, version: HostAppVersion) -> str:
+        return f"{name.replace(' ', '')}{str(version).strip('v')}"
+
+
+RHINO = HostApplication("Rhino", "rhino")
+GRASSHOPPER = HostApplication("Grasshopper", "grasshopper")
+REVIT = HostApplication("Revit", "revit")
+DYNAMO = HostApplication("Dynamo", "dynamo")
+UNITY = HostApplication("Unity", "unity")
+GSA = HostApplication("GSA", "gsa")
+CIVIL = HostApplication("Civil 3D", "civil3d")
+AUTOCAD = HostApplication("AutoCAD", "autocad")
+MICROSTATION = HostApplication("MicroStation", "microstation")
+OPENROADS = HostApplication("OpenRoads", "openroads")
+OPENRAIL = HostApplication("OpenRail", "openrail")
+OPENBUILDINGS = HostApplication("OpenBuildings", "openbuildings")
+ETABS = HostApplication("ETABS", "etabs")
+SAP2000 = HostApplication("SAP2000", "sap2000")
+CSIBRIDGE = HostApplication("CSIBridge", "csibridge")
+SAFE = HostApplication("SAFE", "safe")
+TEKLASTRUCTURES = HostApplication("Tekla Structures", "teklastructures")
+DXF = HostApplication("DXF Converter", "dxf")
+EXCEL = HostApplication("Excel", "excel")
+UNREAL = HostApplication("Unreal", "unreal")
+POWERBI = HostApplication("Power BI", "powerbi")
+BLENDER = HostApplication("Blender", "blender")
+QGIS = HostApplication("QGIS", "qgis")
+ARCGIS = HostApplication("ArcGIS", "arcgis")
+SKETCHUP = HostApplication("SketchUp", "sketchup")
+ARCHICAD = HostApplication("Archicad", "archicad")
+TOPSOLID = HostApplication("TopSolid", "topsolid")
+PYTHON = HostApplication("Python", "python")
+NET = HostApplication(".NET", "net")
+OTHER = HostApplication("Other", "other")
+
+_app_name_host_app_mapping = {
+    "dynamo": DYNAMO,
+    "revit": REVIT,
+    "autocad": AUTOCAD,
+    "civil": CIVIL,
+    "rhino": RHINO,
+    "grasshopper": GRASSHOPPER,
+    "unity": UNITY,
+    "gsa": GSA,
+    "microstation": MICROSTATION,
+    "openroads": OPENROADS,
+    "openrail": OPENRAIL,
+    "openbuildings": OPENBUILDINGS,
+    "etabs": ETABS,
+    "sap": SAP2000,
+    "csibridge": CSIBRIDGE,
+    "safe": SAFE,
+    "teklastructures": TEKLASTRUCTURES,
+    "dxf": DXF,
+    "excel": EXCEL,
+    "unreal": UNREAL,
+    "powerbi": POWERBI,
+    "blender": BLENDER,
+    "qgis": QGIS,
+    "arcgis": ARCGIS,
+    "sketchup": SKETCHUP,
+    "archicad": ARCHICAD,
+    "topsolid": TOPSOLID,
+    "python": PYTHON,
+    "net": NET,
+}
+
+
+def get_host_app_from_string(app_name: str) -> HostApplication:
+    app_name = app_name.lower().replace(" ", "")
+    for partial_app_name, host_app in _app_name_host_app_mapping.items():
+        if partial_app_name in app_name:
+            return host_app
+    return HostApplication(app_name, app_name)
+
+
+if __name__ == "__main__":
+    print(HostAppVersion.v)

src/specklepy/core/api/inputs/__init__.py

@@ -0,0 +1,42 @@
+from specklepy.core.api.inputs.model_inputs import (
+    CreateModelInput,
+    DeleteModelInput,
+    ModelVersionsFilter,
+    UpdateModelInput,
+)
+from specklepy.core.api.inputs.project_inputs import (
+    ProjectCreateInput,
+    ProjectInviteCreateInput,
+    ProjectInviteUseInput,
+    ProjectModelsFilter,
+    ProjectUpdateInput,
+    ProjectUpdateRoleInput,
+)
+from specklepy.core.api.inputs.user_inputs import UserProjectsFilter, UserUpdateInput
+from specklepy.core.api.inputs.version_inputs import (
+    CreateVersionInput,
+    DeleteVersionsInput,
+    MarkReceivedVersionInput,
+    MoveVersionsInput,
+    UpdateVersionInput,
+)
+
+__all__ = [
+    "CreateModelInput",
+    "DeleteModelInput",
+    "UpdateModelInput",
+    "ModelVersionsFilter",
+    "ProjectCreateInput",
+    "ProjectInviteCreateInput",
+    "ProjectInviteUseInput",
+    "ProjectModelsFilter",
+    "ProjectUpdateInput",
+    "ProjectUpdateRoleInput",
+    "UserProjectsFilter",
+    "UserUpdateInput",
+    "UpdateVersionInput",
+    "MoveVersionsInput",
+    "DeleteVersionsInput",
+    "CreateVersionInput",
+    "MarkReceivedVersionInput",
+]

src/specklepy/core/api/inputs/model_inputs.py

@@ -0,0 +1,26 @@
+from typing import Optional, Sequence
+
+from specklepy.core.api.models.graphql_base_model import GraphQLBaseModel
+
+
+class CreateModelInput(GraphQLBaseModel):
+    name: str
+    description: Optional[str] = None
+    project_id: str
+
+
+class DeleteModelInput(GraphQLBaseModel):
+    id: str
+    project_id: str
+
+
+class UpdateModelInput(GraphQLBaseModel):
+    id: str
+    name: Optional[str] = None
+    description: Optional[str] = None
+    project_id: str
+
+
+class ModelVersionsFilter(GraphQLBaseModel):
+    priority_ids: Sequence[str]
+    priority_ids_only: Optional[bool] = None

src/specklepy/core/api/inputs/project_inputs.py

@@ -0,0 +1,62 @@
+from typing import Optional, Sequence
+
+from specklepy.core.api.enums import ProjectVisibility
+from specklepy.core.api.models.graphql_base_model import GraphQLBaseModel
+
+
+class ProjectCreateInput(GraphQLBaseModel):
+    name: Optional[str]
+    description: Optional[str]
+    visibility: Optional[ProjectVisibility]
+
+
+class WorkspaceProjectCreateInput(GraphQLBaseModel):
+    name: Optional[str]
+    description: Optional[str]
+    visibility: Optional[ProjectVisibility]
+    workspaceId: str
+
+
+class ProjectInviteCreateInput(GraphQLBaseModel):
+    email: Optional[str]
+    role: Optional[str]
+    server_role: Optional[str]
+    userId: Optional[str]
+
+
+class ProjectInviteUseInput(GraphQLBaseModel):
+    accept: bool
+    project_id: str
+    token: str
+
+
+class ProjectModelsFilter(GraphQLBaseModel):
+    contributors: Optional[Sequence[str]] = None
+    exclude_ids: Optional[Sequence[str]] = None
+    ids: Optional[Sequence[str]] = None
+    only_with_versions: Optional[bool] = None
+    search: Optional[str] = None
+    source_apps: Optional[Sequence[str]] = None
+
+
+class ProjectUpdateInput(GraphQLBaseModel):
+    id: str
+    name: Optional[str] = None
+    description: Optional[str] = None
+    allow_public_comments: Optional[bool] = None
+    visibility: Optional[ProjectVisibility] = None
+
+
+class ProjectUpdateRoleInput(GraphQLBaseModel):
+    user_id: str
+    project_id: str
+    role: Optional[str]
+
+
+class WorksaceProjectsFilter(GraphQLBaseModel):
+    search: Optional[str]
+    """Filter out projects by name"""
+    with_project_role_only: Optional[bool]
+    """
+    Only return workspace projects that the active user has an explicit project role in
+    """

src/specklepy/core/api/inputs/user_inputs.py

@@ -0,0 +1,22 @@
+from typing import Optional, Sequence
+
+from specklepy.core.api.models.graphql_base_model import GraphQLBaseModel
+
+
+class UserUpdateInput(GraphQLBaseModel):
+    avatar: Optional[str] = None
+    bio: Optional[str] = None
+    company: Optional[str] = None
+    name: Optional[str] = None
+
+
+class UserProjectsFilter(GraphQLBaseModel):
+    search: Optional[str] = None
+    only_with_roles: Optional[Sequence[str]] = None
+    workspace_id: Optional[str] = None
+    personal_only: Optional[bool] = None
+    include_implicit_access: Optional[bool] = None
+
+
+class UserWorkspacesFilter(GraphQLBaseModel):
+    search: Optional[str]

src/specklepy/core/api/inputs/version_inputs.py

@@ -0,0 +1,37 @@
+from typing import Optional, Sequence
+
+from specklepy.core.api.models.graphql_base_model import GraphQLBaseModel
+
+
+class UpdateVersionInput(GraphQLBaseModel):
+    version_id: str
+    project_id: str
+    message: Optional[str]
+
+
+class MoveVersionsInput(GraphQLBaseModel):
+    target_model_name: str
+    version_ids: Sequence[str]
+    project_id: str
+
+
+class DeleteVersionsInput(GraphQLBaseModel):
+    version_ids: Sequence[str]
+    project_id: str
+
+
+class CreateVersionInput(GraphQLBaseModel):
+    object_id: str
+    model_id: str
+    project_id: str
+    message: Optional[str] = None
+    source_application: Optional[str] = "py"
+    total_children_count: Optional[int] = None
+    parents: Optional[Sequence[str]] = None
+
+
+class MarkReceivedVersionInput(GraphQLBaseModel):
+    version_id: str
+    project_id: str
+    source_application: str
+    message: Optional[str] = None

src/specklepy/core/api/models/__init__.py

@@ -0,0 +1,51 @@
+from specklepy.core.api.models.current import (
+    AuthStrategy,
+    LimitedUser,
+    Model,
+    ModelWithVersions,
+    PendingStreamCollaborator,
+    Project,
+    ProjectCollaborator,
+    ProjectCommentCollection,
+    ProjectWithModels,
+    ProjectWithPermissions,
+    ProjectWithTeam,
+    ResourceCollection,
+    ServerConfiguration,
+    ServerInfo,
+    ServerMigration,
+    User,
+    UserSearchResultCollection,
+    Version,
+)
+from specklepy.core.api.models.subscription_messages import (
+    ProjectModelsUpdatedMessage,
+    ProjectUpdatedMessage,
+    ProjectVersionsUpdatedMessage,
+    UserProjectsUpdatedMessage,
+)
+
+__all__ = [
+    "User",
+    "ResourceCollection",
+    "ServerMigration",
+    "AuthStrategy",
+    "ServerConfiguration",
+    "ServerInfo",
+    "LimitedUser",
+    "PendingStreamCollaborator",
+    "ProjectCollaborator",
+    "Version",
+    "Model",
+    "ModelWithVersions",
+    "Project",
+    "ProjectWithModels",
+    "ProjectWithPermissions",
+    "ProjectWithTeam",
+    "ProjectCommentCollection",
+    "UserSearchResultCollection",
+    "UserProjectsUpdatedMessage",
+    "ProjectModelsUpdatedMessage",
+    "ProjectUpdatedMessage",
+    "ProjectVersionsUpdatedMessage",
+]

src/specklepy/core/api/models/current.py

@@ -0,0 +1,227 @@
+from datetime import datetime
+from typing import Generic, List, Optional, TypeVar
+
+from specklepy.core.api.enums import ProjectVisibility
+from specklepy.core.api.models.graphql_base_model import GraphQLBaseModel
+from specklepy.logging.exceptions import WorkspacePermissionException
+
+T = TypeVar("T")
+
+
+class User(GraphQLBaseModel):
+    id: str
+    email: Optional[str] = None
+    name: str
+    bio: Optional[str] = None
+    company: Optional[str] = None
+    avatar: Optional[str] = None
+    verified: Optional[bool] = None
+    role: Optional[str] = None
+
+    def __repr__(self):
+        return (
+            f"User( id: {self.id}, name: {self.name}, email: {self.email}, company:"
+            f" {self.company} )"
+        )
+
+    def __str__(self) -> str:
+        return self.__repr__()
+
+
+class ResourceCollection(GraphQLBaseModel, Generic[T]):
+    total_count: int
+    items: List[T]
+    cursor: Optional[str] = None
+
+
+class ServerMigration(GraphQLBaseModel):
+    moved_from: Optional[str]
+    moved_to: Optional[str]
+
+
+class AuthStrategy(GraphQLBaseModel):
+    color: Optional[str]
+    icon: str
+    id: str
+    name: str
+    url: str
+
+
+class ServerConfiguration(GraphQLBaseModel):
+    blob_size_limit_bytes: int
+    object_multipart_upload_size_limit_bytes: int
+    object_size_limit_bytes: int
+
+
+class ServerWorkspacesInfo(GraphQLBaseModel):
+    workspaces_enabled: bool
+
+
+# Keeping this one all Optionals at the minute,
+#  because its used both as a deserialization model for GQL and Account Management
+class ServerInfo(GraphQLBaseModel):
+    name: Optional[str] = None
+    company: Optional[str] = None
+    url: Optional[str] = None
+    admin_contact: Optional[str] = None
+    description: Optional[str] = None
+    canonical_url: Optional[str] = None
+    scopes: Optional[List[dict]] = None
+    auth_strategies: Optional[List[dict]] = None
+    version: Optional[str] = None
+    migration: Optional[ServerMigration] = None
+    workspaces: Optional[ServerWorkspacesInfo] = None
+    # TODO separate gql model from account management model
+
+
+class LimitedUser(GraphQLBaseModel):
+    """Limited user type, for showing public info about a user to another user."""
+
+    id: str
+    name: str
+    bio: Optional[str]
+    company: Optional[str]
+    avatar: Optional[str]
+    verified: Optional[bool]
+    role: Optional[str]
+
+    def __repr__(self):
+        return (
+            f"(name: {self.name}, "
+            f"id: {self.id}, "
+            f"bio: {self.bio}, "
+            f"company: {self.company}, "
+            f"verified: {self.verified}, "
+            f"role: {self.role})"
+        )
+
+
+class PendingStreamCollaborator(GraphQLBaseModel):
+    id: str
+    invite_id: str
+    stream_id: Optional[str] = None
+    projectId: str
+    stream_name: Optional[str] = None
+    project_name: str
+    title: str
+    role: str
+    invited_by: LimitedUser
+    user: Optional[LimitedUser] = None
+    token: Optional[str]
+
+    def __repr__(self):
+        return (
+            f"PendingStreamCollaborator( inviteId: {self.invite_id}, streamId:"
+            f" {self.stream_id}, role: {self.role}, title: {self.title}, invitedBy:"
+            f" {self.user.name if self.user else None})"
+        )
+
+    def __str__(self) -> str:
+        return self.__repr__()
+
+
+class ProjectCollaborator(GraphQLBaseModel):
+    id: str
+    role: str
+    user: LimitedUser
+
+
+class Version(GraphQLBaseModel):
+    author_user: Optional[LimitedUser]
+    created_at: datetime
+    id: str
+    message: Optional[str]
+    preview_url: str
+    referenced_object: Optional[str]
+    """Maybe null if workspaces version history limit has been exceeded"""
+    source_application: Optional[str]
+
+
+class Model(GraphQLBaseModel):
+    author: Optional[LimitedUser]
+    created_at: datetime
+    description: Optional[str]
+    display_name: str
+    id: str
+    name: str
+    preview_url: Optional[str]
+    updated_at: datetime
+
+
+class ModelWithVersions(Model):
+    versions: ResourceCollection[Version]
+
+
+class ProjectPermissionChecks(GraphQLBaseModel):
+    can_create_model: "PermissionCheckResult"
+    can_delete: "PermissionCheckResult"
+    can_load: "PermissionCheckResult"
+    can_publish: "PermissionCheckResult"
+
+
+class Project(GraphQLBaseModel):
+    allow_public_comments: bool
+    created_at: datetime
+    description: Optional[str]
+    id: str
+    name: str
+    role: Optional[str]
+    source_apps: List[str]
+    updated_at: datetime
+    visibility: ProjectVisibility
+    workspace_id: Optional[str]
+
+
+class ProjectWithModels(Project):
+    models: ResourceCollection[Model]
+
+
+class ProjectWithPermissions(Project):
+    permissions: ProjectPermissionChecks
+
+
+class ProjectWithTeam(Project):
+    invited_team: List[PendingStreamCollaborator]
+    team: List[ProjectCollaborator]
+
+
+class ProjectCommentCollection(ResourceCollection[T], Generic[T]):
+    total_archived_count: int
+
+
+class UserSearchResultCollection(GraphQLBaseModel):
+    items: List[LimitedUser]
+    cursor: Optional[str] = None
+
+
+class PermissionCheckResult(GraphQLBaseModel):
+    authorized: bool
+    code: str
+    message: str
+
+    def ensure_authorised(self) -> None:
+        """Raises WorkspacePermissionException if not authorized"""
+        if not self.authorized:
+            raise WorkspacePermissionException(self.message)
+
+
+class WorkspacePermissionChecks(GraphQLBaseModel):
+    can_create_project: PermissionCheckResult
+
+
+class WorkspaceCreationState(GraphQLBaseModel):
+    completed: bool
+
+
+class Workspace(GraphQLBaseModel):
+    id: str
+    name: str
+    role: Optional[str]
+    slug: str
+    logo: Optional[str]
+    created_at: datetime
+    updated_at: datetime
+    read_only: bool
+    description: Optional[str]
+    creation_state: Optional[WorkspaceCreationState]
+    permissions: WorkspacePermissionChecks

src/specklepy/core/api/models/graphql_base_model.py

@@ -0,0 +1,17 @@
+from pydantic import AliasGenerator, BaseModel, ConfigDict
+from pydantic.alias_generators import to_camel
+
+
+class GraphQLBaseModel(BaseModel):
+    """
+    Parent class for all GraphQL Object Model classes
+    Sets-up a pydantic config to serialize properties using a camel case alias
+    """
+
+    model_config = ConfigDict(
+        alias_generator=AliasGenerator(
+            serialization_alias=to_camel,
+            validation_alias=to_camel,
+        ),
+        populate_by_name=True,
+    )

src/specklepy/core/api/models/subscription_messages.py

@@ -0,0 +1,35 @@
+from typing import Optional
+
+from specklepy.core.api.enums import (
+    ProjectModelsUpdatedMessageType,
+    ProjectUpdatedMessageType,
+    ProjectVersionsUpdatedMessageType,
+    UserProjectsUpdatedMessageType,
+)
+from specklepy.core.api.models.current import Model, Project, Version
+from specklepy.core.api.models.graphql_base_model import GraphQLBaseModel
+
+
+class UserProjectsUpdatedMessage(GraphQLBaseModel):
+    id: str
+    type: UserProjectsUpdatedMessageType
+    project: Optional[Project]
+
+
+class ProjectModelsUpdatedMessage(GraphQLBaseModel):
+    id: str
+    type: ProjectModelsUpdatedMessageType
+    model: Optional[Model]
+
+
+class ProjectUpdatedMessage(GraphQLBaseModel):
+    id: str
+    type: ProjectUpdatedMessageType
+    project: Optional[Project]
+
+
+class ProjectVersionsUpdatedMessage(GraphQLBaseModel):
+    id: str
+    type: ProjectVersionsUpdatedMessageType
+    model_id: str
+    version: Optional[Version]

src/specklepy/core/api/operations.py

@@ -1,15 +1,16 @@
-from typing import List
+from typing import List, Optional
-from specklepy.logging import metrics
+
-from specklepy.objects.base import Base
+# from specklepy.logging import metrics
-from specklepy.transports.sqlite import SQLiteTransport
 from specklepy.logging.exceptions import SpeckleException
-from specklepy.transports.abstract_transport import AbstractTransport
+from specklepy.objects.base import Base
 from specklepy.serialization.base_object_serializer import BaseObjectSerializer
+from specklepy.transports.abstract_transport import AbstractTransport
+from specklepy.transports.sqlite import SQLiteTransport
 
 
 def send(
     base: Base,
-    transports: List[AbstractTransport] = [],
+    transports: Optional[List[AbstractTransport]] = None,
     use_default_cache: bool = True,
 ):
     """Sends an object via the provided transports. Defaults to the local cache.
@@ -17,35 +18,41 @@ def send(
     Arguments:
         obj {Base} -- the object you want to send
         transports {list} -- where you want to send them
-        use_default_cache {bool} -- toggle for the default cache. If set to false, it will only send to the provided transports
+        use_default_cache {bool} -- toggle for the default cache.
+        If set to false, it will only send to the provided transports
 
     Returns:
         str -- the object id of the sent object
     """
-    metrics.track(metrics.SEND)
+
     if not transports and not use_default_cache:
         raise SpeckleException(
-            message="You need to provide at least one transport: cannot send with an empty transport list and no default cache"
+            message=(
+                "You need to provide at least one transport: cannot send with an empty"
+                " transport list and no default cache"
+            )
         )
+
+    if isinstance(transports, AbstractTransport):
+        transports = [transports]
+
+    if transports is None:
+        transports = []
+
     if use_default_cache:
         transports.insert(0, SQLiteTransport())
 
     serializer = BaseObjectSerializer(write_transports=transports)
 
-    for t in transports:
+    obj_hash, _ = serializer.write_json(base=base)
-        t.begin_write()
-    hash, _ = serializer.write_json(base=base)
 
-    for t in transports:
+    return obj_hash
-        t.end_write()
-
-    return hash
 
 
 def receive(
     obj_id: str,
-    remote_transport: AbstractTransport = None,
+    remote_transport: Optional[AbstractTransport] = None,
-    local_transport: AbstractTransport = None,
+    local_transport: Optional[AbstractTransport] = None,
 ) -> Base:
     """Receives an object from a transport.
 
@@ -58,20 +65,23 @@ def receive(
     Returns:
         Base -- the base object
     """
-    metrics.track(metrics.RECEIVE)
     if not local_transport:
         local_transport = SQLiteTransport()
 
     serializer = BaseObjectSerializer(read_transport=local_transport)
 
-    # try local transport first. if the parent is there, we assume all the children are there and continue wth deserialisation using the local transport
+    # try local transport first. if the parent is there, we assume all the children
+    # are there and continue with deserialization using the local transport
     obj_string = local_transport.get_object(obj_id)
     if obj_string:
         return serializer.read_json(obj_string=obj_string)
 
     if not remote_transport:
         raise SpeckleException(
-            message="Could not find the specified object using the local transport, and you didn't provide a fallback remote from which to pull it."
+            message=(
+                "Could not find the specified object using the local transport, and you"
+                " didn't provide a fallback remote from which to pull it."
+            )
         )
 
     obj_string = remote_transport.copy_object_and_children(
@@ -81,40 +91,54 @@ def receive(
     return serializer.read_json(obj_string=obj_string)
 
 
-def serialize(base: Base, write_transports: List[AbstractTransport] = []) -> str:
+def serialize(
+    base: Base, write_transports: List[AbstractTransport] | None = None
+) -> str:
     """
-    Serialize a base object. If no write transports are provided, the object will be serialized
+    Serialize a base object. If no write transports are provided,
+    the object will be serialized
     without detaching or chunking any of the attributes.
 
     Arguments:
         base {Base} -- the object to serialize
-        write_transports {List[AbstractTransport]} -- optional: the transports to write to
+        write_transports {List[AbstractTransport]}
+        -- optional: the transports to write to
 
     Returns:
         str -- the serialized object
     """
-    metrics.track(metrics.SERIALIZE)
+    if not write_transports:
+        write_transports = []
     serializer = BaseObjectSerializer(write_transports=write_transports)
 
     return serializer.write_json(base)[1]
 
 
-def deserialize(obj_string: str, read_transport: AbstractTransport = None) -> Base:
+def deserialize(
+    obj_string: str, read_transport: Optional[AbstractTransport] = None
+) -> Base:
     """
-    Deserialize a string object into a Base object. If the object contains referenced child objects that are not stored in the local db, a read transport needs to be provided in order to recompose the base with the children objects.
+    Deserialize a string object into a Base object.
+
+    If the object contains referenced child objects that are not stored in the local db,
+    a read transport needs to be provided in order to recompose
+    the base with the children objects.
 
     Arguments:
         obj_string {str} -- the string object to deserialize
-        read_transport {AbstractTransport} -- the transport to fetch children objects from
+        read_transport {AbstractTransport}
-                                              (defaults to SQLiteTransport)
+            -- the transport to fetch children objects from
+                (defaults to SQLiteTransport)
 
     Returns:
         Base -- the deserialized object
     """
-    metrics.track(metrics.DESERIALIZE)
     if not read_transport:
         read_transport = SQLiteTransport()
 
     serializer = BaseObjectSerializer(read_transport=read_transport)
 
     return serializer.read_json(obj_string=obj_string)
+
+
+__all__ = ["receive", "send", "serialize", "deserialize"]

src/specklepy/core/api/resource.py

@@ -0,0 +1,166 @@
+from threading import Lock
+from typing import Any, Dict, List, Optional, Tuple, Type, TypeVar, Union
+
+from gql.client import Client
+from gql.transport.exceptions import TransportQueryError
+from graphql import DocumentNode
+from pydantic import BaseModel
+
+from specklepy.core.api.credentials import Account
+from specklepy.logging.exceptions import (
+    GraphQLException,
+    SpeckleException,
+    UnsupportedException,
+)
+from specklepy.serialization.base_object_serializer import BaseObjectSerializer
+from specklepy.transports.sqlite import SQLiteTransport
+
+T = TypeVar("T", bound=BaseModel)
+
+
+class ResourceBase:
+    def __init__(
+        self,
+        account: Account,
+        basepath: str,
+        client: Client,
+        name: str,
+        server_version: Optional[Tuple[Any, ...]] = None,
+    ) -> None:
+        self.account = account
+        self.basepath = basepath
+        self.client = client
+        self.name = name
+        self.server_version = server_version
+        self.schema: Optional[Type] = None
+        self.__lock = Lock()
+
+    def _step_into_response(self, response: dict, return_type: Union[str, List, None]):
+        """Step into the dict to get the relevant data"""
+        if return_type is None:
+            return response
+        if isinstance(return_type, str):
+            return response[return_type]
+        if isinstance(return_type, List):
+            for key in return_type:
+                response = response[key]
+            return response
+
+    def make_request_and_parse_response(
+        self,
+        schema: Type[T],
+        query: DocumentNode,
+        variables: Optional[Dict[str, Any]] = None,
+    ) -> T:
+        try:
+            with self.__lock:
+                response = self.client.execute(query, variable_values=variables)
+        except TransportQueryError as ex:
+            raise GraphQLException(
+                message=(
+                    f"Failed to execute the GraphQL {self.name} request. Errors:"
+                    f" {ex.errors}"
+                ),
+                errors=ex.errors,
+                data=ex.data,
+            ) from ex
+        except Exception as ex:
+            raise SpeckleException(
+                message=(
+                    f"Failed to execute the GraphQL {self.name} request. Inner"
+                    f" exception: {ex}"
+                ),
+                exception=ex,
+            ) from ex
+
+        return schema.model_validate(response)
+
+    def _parse_response(self, response: Union[dict, list, None], schema=None):
+        """Try to create a class instance from the response"""
+        if response is None:
+            return None
+        if isinstance(response, list):
+            return [self._parse_response(response=r, schema=schema) for r in response]
+        if schema:
+            return schema.model_validate(response)
+        elif self.schema:
+            try:
+                return self.schema.model_validate(response)
+            except Exception:
+                s = BaseObjectSerializer(read_transport=SQLiteTransport())
+                return s.recompose_base(response)
+        else:
+            return response
+
+    def make_request(
+        self,
+        query: DocumentNode,
+        params: Optional[Dict] = None,
+        return_type: Union[str, List, None] = None,
+        schema=None,
+        parse_response: bool = True,
+    ) -> Any:
+        """Executes the GraphQL query"""
+        # This method has quite complex and ambiguous typing,
+        # and counter-intuitive error handling
+        # We are going to phase it out in favour of `make_request_and_parse_response`
+        try:
+            with self.__lock:
+                response = self.client.execute(query, variable_values=params)
+        except Exception as ex:
+            if isinstance(ex, TransportQueryError):
+                return GraphQLException(
+                    message=(
+                        f"Failed to execute the GraphQL {self.name} request. Errors:"
+                        f" {ex.errors}"
+                    ),
+                    errors=ex.errors,
+                    data=ex.data,
+                )
+            else:
+                return SpeckleException(
+                    message=(
+                        f"Failed to execute the GraphQL {self.name} request. Inner"
+                        f" exception: {ex}"
+                    ),
+                    exception=ex,
+                )
+
+        response = self._step_into_response(response=response, return_type=return_type)
+
+        if parse_response:
+            return self._parse_response(response=response, schema=schema)
+        else:
+            return response
+
+    def _check_server_version_at_least(
+        self, target_version: Tuple[Any, ...], unsupported_message: Optional[str] = None
+    ):
+        """Use this check to guard against making unsupported requests on older servers.
+
+        Arguments:
+            target_version {tuple}
+            the minimum server version in the format (major, minor, patch, (tag, build))
+            eg (2, 6, 3) for a stable build and (2, 6, 4, 'alpha', 4711) for alpha
+        """
+        if not unsupported_message:
+            unsupported_message = (
+                "The client method used is not supported on Speckle Server versions"
+                f" prior to v{'.'.join(target_version)}"
+            )
+        # if version is dev, it should be supported... (or not)
+        if self.server_version == ("dev",):
+            return
+        if self.server_version and self.server_version < target_version:
+            raise UnsupportedException(unsupported_message)
+
+    def _check_invites_supported(self):
+        """Invites are only supported for Speckle Server >= 2.6.4.
+        Use this check to guard against making unsupported requests on older servers.
+        """
+        self._check_server_version_at_least(
+            (2, 6, 4),
+            "Stream invites are only supported as of Speckle Server v2.6.4. Please"
+            " update your Speckle Server to use this method or use the"
+            " `grant_permission` flow instead.",
+        )

src/specklepy/core/api/resources/__init__.py

@@ -0,0 +1,25 @@
+from specklepy.core.api.resources.current.active_user_resource import ActiveUserResource
+from specklepy.core.api.resources.current.model_resource import ModelResource
+from specklepy.core.api.resources.current.other_user_resource import OtherUserResource
+from specklepy.core.api.resources.current.project_invite_resource import (
+    ProjectInviteResource,
+)
+from specklepy.core.api.resources.current.project_resource import ProjectResource
+from specklepy.core.api.resources.current.server_resource import ServerResource
+from specklepy.core.api.resources.current.subscription_resource import (
+    SubscriptionResource,
+)
+from specklepy.core.api.resources.current.version_resource import VersionResource
+from specklepy.core.api.resources.current.workspace_resource import WorkspaceResource
+
+__all__ = [
+    "ActiveUserResource",
+    "ModelResource",
+    "OtherUserResource",
+    "ProjectInviteResource",
+    "ProjectResource",
+    "ServerResource",
+    "SubscriptionResource",
+    "VersionResource",
+    "WorkspaceResource",
+]

src/specklepy/core/api/resources/current/active_user_resource.py

@@ -0,0 +1,425 @@
+from typing import List, Optional
+
+from gql import gql
+
+from specklepy.core.api.inputs.user_inputs import (
+    UserProjectsFilter,
+    UserUpdateInput,
+    UserWorkspacesFilter,
+)
+from specklepy.core.api.models import (
+    PendingStreamCollaborator,
+    Project,
+    ResourceCollection,
+    User,
+)
+from specklepy.core.api.models.current import (
+    PermissionCheckResult,
+    ProjectWithPermissions,
+    Workspace,
+)
+from specklepy.core.api.resource import ResourceBase
+from specklepy.core.api.responses import DataResponse
+from specklepy.logging.exceptions import GraphQLException
+
+NAME = "active_user"
+
+
+class ActiveUserResource(ResourceBase):
+    """API Access class for the active user"""
+
+    def __init__(self, account, basepath, client, server_version) -> None:
+        super().__init__(
+            account=account,
+            basepath=basepath,
+            client=client,
+            name=NAME,
+            server_version=server_version,
+        )
+        self.schema = User
+
+    def get(self) -> Optional[User]:
+        """Gets the currently active user profile
+        (as extracted from the authorization header)
+
+        Returns:
+            User -- the requested user, or none if no authentication token
+            is provided to the Client
+        """
+        QUERY = gql(
+            """
+            query User {
+             data:activeUser {
+               id
+               email
+               name
+               bio
+               company
+               avatar
+               verified
+               role
+             }
+           }
+           """
+        )
+
+        variables = {}
+
+        return self.make_request_and_parse_response(
+            DataResponse[Optional[User]], QUERY, variables
+        ).data
+
+    def update(self, input: UserUpdateInput) -> User:
+        QUERY = gql(
+            """
+            mutation ActiveUserMutations($input: UserUpdateInput!) {
+              data:activeUserMutations {
+                data:update(user: $input) {
+                  id
+                  email
+                  name
+                  bio
+                  company
+                  avatar
+                  verified
+                  role
+                }
+              }
+            }
+           """
+        )
+
+        variables = {"input": input.model_dump(warnings="error", by_alias=True)}
+
+        return self.make_request_and_parse_response(
+            DataResponse[DataResponse[User]], QUERY, variables
+        ).data.data
+
+    def get_projects(
+        self,
+        *,
+        limit: int = 25,
+        cursor: Optional[str] = None,
+        filter: Optional[UserProjectsFilter] = None,
+    ) -> ResourceCollection[Project]:
+        QUERY = gql(
+            """
+             query User($limit : Int!, $cursor: String, $filter: UserProjectsFilter) {
+              data:activeUser {
+                data:projects(limit: $limit, cursor: $cursor, filter: $filter) {
+                   totalCount
+                   cursor
+                   items {
+                      id
+                      name
+                      description
+                      visibility
+                      allowPublicComments
+                      role
+                      createdAt
+                      updatedAt
+                      sourceApps
+                      workspaceId
+                   }
+                }
+              }
+            }
+            """
+        )
+
+        variables = {
+            "limit": limit,
+            "cursor": cursor,
+            "filter": filter.model_dump(warnings="error", by_alias=True)
+            if filter
+            else None,
+        }
+
+        response = self.make_request_and_parse_response(
+            DataResponse[Optional[DataResponse[ResourceCollection[Project]]]],
+            QUERY,
+            variables,
+        )
+
+        if response.data is None:
+            raise GraphQLException(
+                "GraphQL response indicated that the ActiveUser could not be found"
+            )
+
+        return response.data.data
+
+    def get_project_invites(self) -> List[PendingStreamCollaborator]:
+        QUERY = gql(
+            """
+            query ProjectInvites {
+              data:activeUser {
+                data:projectInvites {
+                  id
+                  inviteId
+                  invitedBy {
+                    avatar
+                    bio
+                    company
+                    id
+                    name
+                    role
+                    verified
+                  }
+                  projectId
+                  projectName
+                  role
+                  title
+                  token
+                  user {
+                    id
+                    name
+                    bio
+                    company
+                    verified
+                    avatar
+                    role
+                  }
+                }
+              }
+            }
+            """
+        )
+
+        variables = {}
+
+        response = self.make_request_and_parse_response(
+            DataResponse[Optional[DataResponse[List[PendingStreamCollaborator]]]],
+            QUERY,
+            variables,
+        )
+
+        if response.data is None:
+            raise GraphQLException(
+                "GraphQL response indicated that the ActiveUser could not be found"
+            )
+
+        return response.data.data
+
+    def can_create_personal_projects(self) -> PermissionCheckResult:
+        QUERY = gql(
+            """
+            query CanCreatePersonalProject {
+              data:activeUser {
+                data:permissions {
+                  data:canCreatePersonalProject {
+                    authorized
+                    code
+                    message
+                  }
+                }
+              }
+            }
+            """
+        )
+
+        response = self.make_request_and_parse_response(
+            DataResponse[Optional[DataResponse[DataResponse[PermissionCheckResult]]]],
+            QUERY,
+        )
+
+        if response.data is None:
+            raise GraphQLException(
+                "GraphQL response indicated that the ActiveUser could not be found"
+            )
+
+        return response.data.data.data
+
+    def get_workspaces(
+        self,
+        limit: int = 25,
+        cursor: Optional[str] = None,
+        filter: Optional[UserWorkspacesFilter] = None,
+    ) -> ResourceCollection[Workspace]:
+        """
+        This feature is only available on Workspace enabled servers  (server versions
+        >=2.23.17) e.g. app.speckle.systems
+        """
+        QUERY = gql(
+            """
+            query ActiveUser($limit: Int!, $cursor: String, $filter: UserWorkspacesFilter) {
+              data:activeUser {
+                data:workspaces(limit: $limit, cursor: $cursor, filter: $filter) {
+                  cursor
+                  totalCount
+                  items {
+                    id
+                    name
+                    role
+                    slug
+                    logo
+                    createdAt
+                    updatedAt
+                    readOnly
+                    description
+                    creationState
+                    {
+                      completed
+                    }
+                    permissions {
+                      canCreateProject {
+                        authorized
+                        code
+                        message
+                      }
+                    }
+                  }
+                }
+              }
+            }
+            """  # noqa: E501
+        )
+
+        variables = {
+            "limit": limit,
+            "cursor": cursor,
+            "filter": filter.model_dump(warnings="error", by_alias=True)
+            if filter
+            else None,
+        }
+
+        response = self.make_request_and_parse_response(
+            DataResponse[Optional[DataResponse[ResourceCollection[Workspace]]]],
+            QUERY,
+            variables,
+        )
+
+        if response.data is None:
+            raise GraphQLException(
+                "GraphQL response indicated that the ActiveUser could not be found"
+            )
+
+        return response.data.data
+
+    def get_active_workspace(self) -> Optional[Workspace]:
+        """
+        This feature is only available on Workspace enabled servers  (server versions
+        >=2.23.17) e.g. app.speckle.systems
+        """
+        QUERY = gql(
+            """
+            query ActiveUser {
+              data:activeUser {
+                data:activeWorkspace {
+                  id
+                  name
+                  role
+                  slug
+                  logo
+                  createdAt
+                  updatedAt
+                  readOnly
+                  description
+                  creationState
+                  {
+                    completed
+                  }
+                  permissions {
+                    canCreateProject {
+                      authorized
+                      code
+                      message
+                    }
+                  }
+                }
+              }
+            }
+            """  # noqa: E501
+        )
+
+        response = self.make_request_and_parse_response(
+            DataResponse[Optional[DataResponse[Optional[Workspace]]]],
+            QUERY,
+        )
+
+        if response.data is None:
+            raise GraphQLException(
+                "GraphQL response indicated that the ActiveUser could not be found"
+            )
+
+        return response.data.data
+
+    def get_projects_with_permissions(
+        self,
+        *,
+        limit: int = 25,
+        cursor: Optional[str] = None,
+        filter: Optional[UserProjectsFilter] = None,
+    ) -> ResourceCollection[ProjectWithPermissions]:
+        """
+        Gets the currently active user's projects with their permissions.
+        This is useful for checking what actions can be performed on each project.
+        """
+        QUERY = gql(
+            """
+          query User($limit : Int!, $cursor: String, $filter: UserProjectsFilter) {
+            data:activeUser {
+              data:projects(limit: $limit, cursor: $cursor, filter: $filter) {
+                totalCount
+                cursor
+                items {
+                    id
+                    name
+                    description
+                    visibility
+                    allowPublicComments
+                    role
+                    createdAt
+                    updatedAt
+                    sourceApps
+                    workspaceId
+                    permissions {
+                      canCreateModel {
+                        code
+                        authorized
+                        message
+                      }
+                      canDelete {
+                        code
+                        authorized
+                        message
+                      }
+                      canLoad {
+                        code
+                        authorized
+                        message
+                      }
+                      canPublish {
+                        code
+                        authorized
+                        message
+                      }
+                    }
+                }
+              }
+            }
+          }
+          """
+        )
+
+        variables = {
+            "limit": limit,
+            "cursor": cursor,
+            "filter": filter.model_dump(warnings="error", by_alias=True)
+            if filter
+            else None,
+        }
+
+        response = self.make_request_and_parse_response(
+            DataResponse[
+                Optional[DataResponse[ResourceCollection[ProjectWithPermissions]]]
+            ],
+            QUERY,
+            variables,
+        )
+
+        if response.data is None:
+            raise GraphQLException(
+                "GraphQL response indicated that the ActiveUser could not be found"
+            )
+
+        return response.data.data

src/specklepy/core/api/resources/current/model_resource.py

@@ -0,0 +1,301 @@
+from typing import Optional
+
+from gql import gql
+
+from specklepy.core.api.inputs.model_inputs import (
+    CreateModelInput,
+    DeleteModelInput,
+    ModelVersionsFilter,
+    UpdateModelInput,
+)
+from specklepy.core.api.inputs.project_inputs import ProjectModelsFilter
+from specklepy.core.api.models import Model, ModelWithVersions, ResourceCollection
+from specklepy.core.api.resource import ResourceBase
+from specklepy.core.api.responses import DataResponse
+
+NAME = "model"
+
+
+class ModelResource(ResourceBase):
+    """API Access class for models"""
+
+    def __init__(self, account, basepath, client, server_version) -> None:
+        super().__init__(
+            account=account,
+            basepath=basepath,
+            client=client,
+            name=NAME,
+            server_version=server_version,
+        )
+
+    def get(self, model_id: str, project_id: str) -> Model:
+        QUERY = gql(
+            """
+            query ModelGet($modelId: String!, $projectId: String!) {
+              data:project(id: $projectId) {
+                data:model(id: $modelId) {
+                  id
+                  name
+                  previewUrl
+                  updatedAt
+                  description
+                  displayName
+                  createdAt
+                  author {
+                    avatar
+                    bio
+                    company
+                    id
+                    name
+                    role
+                    verified
+                  }
+                }
+              }
+            }
+            """
+        )
+
+        variables = {
+            "modelId": model_id,
+            "projectId": project_id,
+        }
+
+        return self.make_request_and_parse_response(
+            DataResponse[DataResponse[Model]], QUERY, variables
+        ).data.data
+
+    def get_with_versions(
+        self,
+        model_id: str,
+        project_id: str,
+        *,
+        versions_limit: int = 25,
+        versions_cursor: Optional[str] = None,
+        versions_filter: Optional[ModelVersionsFilter] = None,
+    ) -> ModelWithVersions:
+        QUERY = gql(
+            """
+            query ModelGetWithVersions(
+              $modelId: String!,
+              $projectId: String!,
+              $versionsLimit: Int!,
+              $versionsCursor: String,
+              $versionsFilter: ModelVersionsFilter
+              ) {
+              data:project(id: $projectId) {
+                data:model(id: $modelId) {
+                  id
+                  name
+                  previewUrl
+                  updatedAt
+                  versions(
+                    limit: $versionsLimit,
+                    cursor: $versionsCursor,
+                    filter: $versionsFilter
+                    ) {
+                    items {
+                      id
+                      referencedObject
+                      message
+                      sourceApplication
+                      createdAt
+                      previewUrl
+                      authorUser {
+                        avatar
+                        id
+                        name
+                        bio
+                        company
+                        verified
+                        role
+                      }
+                    }
+                    totalCount
+                    cursor
+                  }
+                  description
+                  displayName
+                  createdAt
+                  author {
+                    avatar
+                    bio
+                    company
+                    id
+                    name
+                    role
+                    verified
+                  }
+                }
+              }
+            }
+            """
+        )
+
+        variables = {
+            "projectId": project_id,
+            "modelId": model_id,
+            "versionsLimit": versions_limit,
+            "versionsCursor": versions_cursor,
+            "versionsFilter": (
+                versions_filter.model_dump(warnings="error", by_alias=True)
+                if versions_filter
+                else None
+            ),
+        }
+
+        return self.make_request_and_parse_response(
+            DataResponse[DataResponse[ModelWithVersions]], QUERY, variables
+        ).data.data
+
+    def get_models(
+        self,
+        project_id: str,
+        *,
+        models_limit: int = 25,
+        models_cursor: Optional[str] = None,
+        models_filter: Optional[ProjectModelsFilter] = None,
+    ) -> ResourceCollection[Model]:
+        QUERY = gql(
+            """
+            query ProjectGetWithModels(
+              $projectId: String!,
+              $modelsLimit: Int!,
+              $modelsCursor: String,
+              $modelsFilter: ProjectModelsFilter
+              ) {
+              data:project(id: $projectId) {
+                data:models(
+                  limit: $modelsLimit,
+                  cursor: $modelsCursor,
+                  filter: $modelsFilter
+                  ) {
+                  items {
+                    id
+                    name
+                    previewUrl
+                    updatedAt
+                    displayName
+                    description
+                    createdAt
+                    author {
+                      avatar
+                      bio
+                      company
+                      id
+                      name
+                      role
+                      verified
+                    }
+                  }
+                  totalCount
+                  cursor
+                }
+              }
+            }
+            """
+        )
+
+        variables = {
+            "projectId": project_id,
+            "modelsLimit": models_limit,
+            "modelsCursor": models_cursor,
+            "modelsFilter": (
+                models_filter.model_dump(warnings="error", by_alias=True)
+                if models_filter
+                else None
+            ),
+        }
+
+        return self.make_request_and_parse_response(
+            DataResponse[DataResponse[ResourceCollection[Model]]], QUERY, variables
+        ).data.data
+
+    def create(self, input: CreateModelInput) -> Model:
+        QUERY = gql(
+            """
+            mutation ModelCreate($input: CreateModelInput!) {
+              data:modelMutations {
+                data:create(input: $input) {
+                  id
+                  displayName
+                  name
+                  description
+                  createdAt
+                  updatedAt
+                  previewUrl
+                  author {
+                    avatar
+                    bio
+                    company
+                    id
+                    name
+                    role
+                    verified
+                  }
+                }
+              }
+            }
+            """
+        )
+
+        variables = {
+            "input": input.model_dump(warnings="error", by_alias=True),
+        }
+
+        return self.make_request_and_parse_response(
+            DataResponse[DataResponse[Model]], QUERY, variables
+        ).data.data
+
+    def delete(self, input: DeleteModelInput) -> bool:
+        QUERY = gql(
+            """
+            mutation ModelDelete($input: DeleteModelInput!) {
+              data:modelMutations {
+                data:delete(input: $input)
+              }
+            }
+            """
+        )
+
+        variables = {"input": input.model_dump(warnings="error", by_alias=True)}
+
+        return self.make_request_and_parse_response(
+            DataResponse[DataResponse[bool]], QUERY, variables
+        ).data.data
+
+    def update(self, input: UpdateModelInput) -> Model:
+        QUERY = gql(
+            """
+            mutation ModelUpdate($input: UpdateModelInput!) {
+              data:modelMutations {
+                data:update(input: $input) {
+                  id
+                  name
+                  displayName
+                  description
+                  createdAt
+                  updatedAt
+                  previewUrl
+                  author {
+                    avatar
+                    bio
+                    company
+                    id
+                    name
+                    role
+                    verified
+                  }
+                }
+              }
+            }
+            """
+        )
+
+        variables = {
+            "input": input.model_dump(warnings="error", by_alias=True),
+        }
+
+        return self.make_request_and_parse_response(
+            DataResponse[DataResponse[Model]], QUERY, variables
+        ).data.data

src/specklepy/core/api/resources/current/other_user_resource.py

@@ -0,0 +1,124 @@
+from typing import Optional
+
+from gql import gql
+
+from specklepy.core.api.models import (
+    LimitedUser,
+    UserSearchResultCollection,
+)
+from specklepy.core.api.resource import ResourceBase
+from specklepy.core.api.responses import DataResponse
+
+NAME = "other_user"
+
+
+class OtherUserResource(ResourceBase):
+    """API Access class for other users, that are not the currently active user."""
+
+    def __init__(self, account, basepath, client, server_version) -> None:
+        super().__init__(
+            account=account,
+            basepath=basepath,
+            client=client,
+            name=NAME,
+            server_version=server_version,
+        )
+        self.schema = LimitedUser
+
+    def get(self, id: str) -> Optional[LimitedUser]:
+        """
+        Gets the profile of another user.
+
+        Arguments:
+            id {str} -- the user id
+
+        Returns:
+            LimitedUser -- the retrieved profile of another user
+        """
+        QUERY = gql(
+            """
+          query LimitedUser($id: String!) {
+            data:otherUser(id: $id){
+              id
+              name
+              bio
+              company
+              avatar
+              verified
+              role
+            }
+          }
+          """
+        )
+
+        variables = {"id": id}
+
+        return self.make_request_and_parse_response(
+            DataResponse[Optional[LimitedUser]], QUERY, variables
+        ).data
+
+    def user_search(
+        self,
+        query: str,
+        *,
+        limit: int = 25,
+        cursor: Optional[str] = None,
+        archived: bool = False,
+        emailOnly: bool = False,
+    ) -> UserSearchResultCollection:
+        """
+        Searches for a user on the server, by name or email.
+        The search query must be at least
+        3 characters long
+
+        Arguments:
+            search_query {str} -- a string to search for
+            limit {int} -- the maximum number of results to return
+            cursor {Optional[str]} --
+            archived {bool} --
+            emailOnly {bool} --
+        Returns:
+            ResourceCollection[LimitedUser] -- User objects that match the search query
+        """
+
+        QUERY = gql(
+            """
+            query UserSearch(
+                $query: String!,
+                $limit: Int!,
+                $cursor: String,
+                $archived: Boolean,
+                $emailOnly: Boolean
+            ) {
+              data:userSearch(
+                query: $query,
+                limit: $limit,
+                cursor: $cursor,
+                archived: $archived,
+                emailOnly: $emailOnly
+                ) {
+                cursor
+                items {
+                 id
+                 name
+                 bio
+                 company
+                 avatar
+                 verified
+                 role
+               }
+             }
+            }
+            """
+        )
+        variables = {
+            "query": query,
+            "limit": limit,
+            "cursor": cursor,
+            "archived": archived,
+            "emailOnly": emailOnly,
+        }
+
+        return self.make_request_and_parse_response(
+            DataResponse[UserSearchResultCollection], QUERY, variables
+        ).data

src/specklepy/core/api/resources/current/project_invite_resource.py

@@ -0,0 +1,257 @@
+from typing import Any, Optional, Tuple
+
+from gql import Client, gql
+
+from specklepy.core.api.credentials import Account
+from specklepy.core.api.inputs.project_inputs import (
+    ProjectInviteCreateInput,
+    ProjectInviteUseInput,
+)
+from specklepy.core.api.models import PendingStreamCollaborator, ProjectWithTeam
+from specklepy.core.api.resource import ResourceBase
+from specklepy.core.api.responses import DataResponse
+
+NAME = "project_invite"
+
+
+class ProjectInviteResource(ResourceBase):
+    """API Access class for project invites"""
+
+    def __init__(
+        self,
+        account: Account,
+        basepath: str,
+        client: Client,
+        server_version: Optional[Tuple[Any, ...]],
+    ) -> None:
+        super().__init__(
+            account=account,
+            basepath=basepath,
+            client=client,
+            name=NAME,
+            server_version=server_version,
+        )
+
+    def create(
+        self, project_id: str, input: ProjectInviteCreateInput
+    ) -> ProjectWithTeam:
+        QUERY = gql(
+            """
+            mutation ProjectInviteCreate(
+              $projectId: ID!,
+              $input: ProjectInviteCreateInput!
+              ) {
+              data:projectMutations {
+                data:invites {
+                  data:create(projectId: $projectId, input: $input) {
+                    id
+                    name
+                    description
+                    visibility
+                    allowPublicComments
+                    role
+                    createdAt
+                    updatedAt
+                    workspaceId
+                    sourceApps
+                    team {
+                      id
+                      role
+                      user {
+                        id
+                        name
+                        bio
+                        company
+                        avatar
+                        verified
+                        role
+                      }
+                    }
+                    invitedTeam {
+                      id
+                      inviteId
+                      projectId
+                      projectName
+                      title
+                      role
+                      token
+                      user {
+                        id
+                        name
+                        bio
+                        company
+                        avatar
+                        verified
+                        role
+                      }
+                      invitedBy {
+                        id
+                        name
+                        bio
+                        company
+                        avatar
+                        verified
+                        role
+                      }
+                    }
+                  }
+                }
+              }
+            }
+            """
+        )
+
+        variables = {
+            "projectId": project_id,
+            "input": input.model_dump(warnings="error", by_alias=True),
+        }
+
+        return self.make_request_and_parse_response(
+            DataResponse[DataResponse[DataResponse[ProjectWithTeam]]], QUERY, variables
+        ).data.data.data
+
+    def use(self, input: ProjectInviteUseInput) -> bool:
+        QUERY = gql(
+            """
+            mutation ProjectInviteUse($input: ProjectInviteUseInput!) {
+              data:projectMutations {
+                data:invites {
+                  data:use(input: $input)
+                }
+              }
+            }
+            """
+        )
+
+        variables = {
+            "input": input.model_dump(warnings="error", by_alias=True),
+        }
+
+        return self.make_request_and_parse_response(
+            DataResponse[DataResponse[DataResponse[bool]]], QUERY, variables
+        ).data.data.data
+
+    def get(
+        self, project_id: str, token: Optional[str]
+    ) -> Optional[PendingStreamCollaborator]:
+        """Returns: The invite, or None if no invite exists"""
+
+        QUERY = gql(
+            """
+            query ProjectInvite($projectId: String!, $token: String) {
+              data:projectInvite(projectId: $projectId, token: $token) {
+                id
+                inviteId
+                invitedBy {
+                  avatar
+                  bio
+                  company
+                  id
+                  name
+                  role
+                  verified
+                }
+                projectId
+                projectName
+                role
+                title
+                token
+                user {
+                  avatar
+                  bio
+                  company
+                  id
+                  name
+                  role
+                  verified
+                }
+              }
+            }
+            """
+        )
+
+        variables = {
+            "projectId": project_id,
+            "token": token,
+        }
+
+        return self.make_request_and_parse_response(
+            DataResponse[Optional[PendingStreamCollaborator]], QUERY, variables
+        ).data
+
+    def cancel(
+        self,
+        project_id: str,
+        invite_id: str,
+    ) -> ProjectWithTeam:
+        QUERY = gql(
+            """
+            mutation ProjectInviteCancel($projectId: ID!, $inviteId: String!) {
+              data:projectMutations {
+                data:invites {
+                  data:cancel(projectId: $projectId, inviteId: $inviteId) {
+                    id
+                    name
+                    description
+                    visibility
+                    allowPublicComments
+                    role
+                    createdAt
+                    updatedAt
+                    sourceApps
+                    workspaceId
+                    team {
+                      id
+                      role
+                      user {
+                        id
+                        name
+                        bio
+                        company
+                        avatar
+                        verified
+                        role
+                      }
+                    }
+                    invitedTeam {
+                      id
+                      inviteId
+                      projectId
+                      projectName
+                      title
+                      role
+                      token
+                      user {
+                        id
+                        name
+                        bio
+                        company
+                        avatar
+                        verified
+                        role
+                      }
+                      invitedBy {
+                        id
+                        name
+                        bio
+                        company
+                        avatar
+                        verified
+                        role
+                      }
+                    }
+                  }
+                }
+              }
+            }
+            """
+        )
+
+        variables = {
+            "projectId": project_id,
+            "inviteId": invite_id,
+        }
+
+        return self.make_request_and_parse_response(
+            DataResponse[DataResponse[DataResponse[ProjectWithTeam]]], QUERY, variables
+        ).data.data.data

src/specklepy/core/api/resources/current/project_resource.py

@@ -0,0 +1,438 @@
+from typing import Optional
+
+from gql import gql
+
+from specklepy.core.api.inputs.project_inputs import (
+    ProjectCreateInput,
+    ProjectModelsFilter,
+    ProjectUpdateInput,
+    ProjectUpdateRoleInput,
+    WorkspaceProjectCreateInput,
+)
+from specklepy.core.api.models import (
+    Project,
+    ProjectWithModels,
+    ProjectWithTeam,
+)
+from specklepy.core.api.models.current import ProjectPermissionChecks
+from specklepy.core.api.resource import ResourceBase
+from specklepy.core.api.responses import DataResponse
+
+NAME = "project"
+
+
+class ProjectResource(ResourceBase):
+    """API Access class for projects"""
+
+    def __init__(self, account, basepath, client, server_version) -> None:
+        super().__init__(
+            account=account,
+            basepath=basepath,
+            client=client,
+            name=NAME,
+            server_version=server_version,
+        )
+
+    def get(self, project_id: str) -> Project:
+        QUERY = gql(
+            """
+            query Project($projectId: String!) {
+              data:project(id: $projectId) {
+                allowPublicComments
+                createdAt
+                description
+                id
+                name
+                role
+                sourceApps
+                updatedAt
+                visibility
+                workspaceId
+              }
+            }
+            """
+        )
+
+        variables = {
+            "projectId": project_id,
+        }
+
+        return self.make_request_and_parse_response(
+            DataResponse[Project], QUERY, variables
+        ).data
+
+    def get_permissions(self, project_id: str) -> ProjectPermissionChecks:
+        QUERY = gql(
+            """
+            query Project($projectId: String!) {
+              data:project(id: $projectId) {
+                data:permissions {
+                  canCreateModel {
+                    authorized
+                    code
+                    message
+                  }
+                  canDelete {
+                    authorized
+                    code
+                    message
+                  }
+                  canLoad {
+                    authorized
+                    code
+                    message
+                  }
+                  canPublish {
+                    authorized
+                    code
+                    message
+                  }
+                }
+              }
+            }
+            """
+        )
+
+        variables = {
+            "projectId": project_id,
+        }
+
+        return self.make_request_and_parse_response(
+            DataResponse[DataResponse[ProjectPermissionChecks]], QUERY, variables
+        ).data.data
+
+    def get_with_models(
+        self,
+        project_id: str,
+        *,
+        models_limit: int = 25,
+        models_cursor: Optional[str] = None,
+        models_filter: Optional[ProjectModelsFilter] = None,
+    ) -> ProjectWithModels:
+        QUERY = gql(
+            """
+            query ProjectGetWithModels(
+              $projectId: String!,
+              $modelsLimit: Int!,
+              $modelsCursor: String,
+              $modelsFilter: ProjectModelsFilter
+              ) {
+              data:project(id: $projectId) {
+                id
+                name
+                description
+                visibility
+                allowPublicComments
+                role
+                createdAt
+                updatedAt
+                sourceApps
+                workspaceId
+                models(
+                  limit: $modelsLimit,
+                  cursor: $modelsCursor,
+                  filter: $modelsFilter
+                  ) {
+                  items {
+                    id
+                    name
+                    previewUrl
+                    updatedAt
+                    displayName
+                    description
+                    createdAt
+                    author {
+                      avatar
+                      bio
+                      company
+                      id
+                      name
+                      role
+                      verified
+                    }
+                  }
+                  cursor
+                  totalCount
+                }
+              }
+            }
+            """
+        )
+
+        variables = {
+            "projectId": project_id,
+            "modelsLimit": models_limit,
+            "modelsCursor": models_cursor,
+            "modelsFilter": (
+                models_filter.model_dump(warnings="error", by_alias=True)
+                if models_filter
+                else None
+            ),
+        }
+
+        return self.make_request_and_parse_response(
+            DataResponse[ProjectWithModels], QUERY, variables
+        ).data
+
+    def get_with_team(self, project_id: str) -> ProjectWithTeam:
+        QUERY = gql(
+            """
+            query ProjectGetWithTeam($projectId: String!) {
+              data:project(id: $projectId) {
+                id
+                name
+                description
+                visibility
+                allowPublicComments
+                role
+                createdAt
+                updatedAt
+                workspaceId
+                sourceApps
+                team {
+                  id
+                  role
+                  user {
+                    id
+                    name
+                    bio
+                    company
+                    avatar
+                    verified
+                    role
+                  }
+                }
+                invitedTeam {
+                  id
+                  inviteId
+                  projectId
+                  projectName
+                  title
+                  role
+                  token
+                  user {
+                    id
+                    name
+                    bio
+                    company
+                    avatar
+                    verified
+                    role
+                  }
+                  invitedBy {
+                    id
+                    name
+                    bio
+                    company
+                    avatar
+                    verified
+                    role
+                  }
+                }
+                workspaceId
+              }
+            }
+            """
+        )
+
+        variables = {
+            "projectId": project_id,
+        }
+
+        return self.make_request_and_parse_response(
+            DataResponse[ProjectWithTeam], QUERY, variables
+        ).data
+
+    def create(self, input: ProjectCreateInput) -> Project:
+        """
+        Creates a non-workspace project (aka Personal Project)
+
+        see client.active_user.can_create_personal_projects to see if the user has
+        permission
+        """
+        QUERY = gql(
+            """
+            mutation ProjectCreate($input: ProjectCreateInput) {
+              data:projectMutations {
+                data:create(input: $input) {
+                  id
+                  name
+                  description
+                  visibility
+                  allowPublicComments
+                  role
+                  createdAt
+                  updatedAt
+                  sourceApps
+                  workspaceId
+                }
+              }
+            }
+            """
+        )
+
+        variables = {
+            "input": input.model_dump(warnings="error", by_alias=True),
+        }
+
+        return self.make_request_and_parse_response(
+            DataResponse[DataResponse[Project]], QUERY, variables
+        ).data.data
+
+    def create_in_workspace(self, input: WorkspaceProjectCreateInput) -> Project:
+        """
+        Creates a workspace project
+        This feature is only supported by Workspace Enabled Servers
+        (e.g. app.speckle.systems)
+
+        see `workspace.permissions.can_create_project` to see if the user has permission
+        """
+        QUERY = gql(
+            """
+          mutation WorkspaceProjectCreate($input: WorkspaceProjectCreateInput!) {
+            data:workspaceMutations {
+              data:projects {
+                data:create(input: $input) {
+                  id
+                  name
+                  description
+                  visibility
+                  allowPublicComments
+                  role
+                  createdAt
+                  updatedAt
+                  sourceApps
+                  workspaceId
+                }
+              }
+            }
+          }
+          """
+        )
+
+        variables = {
+            "input": input.model_dump(warnings="error", by_alias=True),
+        }
+
+        return self.make_request_and_parse_response(
+            DataResponse[DataResponse[DataResponse[Project]]], QUERY, variables
+        ).data.data.data
+
+    def update(self, input: ProjectUpdateInput) -> Project:
+        QUERY = gql(
+            """
+            mutation ProjectUpdate($input: ProjectUpdateInput!) {
+              data:projectMutations{
+                data:update(update: $input) {
+                  allowPublicComments
+                  createdAt
+                  description
+                  id
+                  name
+                  role
+                  sourceApps
+                  updatedAt
+                  visibility
+                  workspaceId
+                }
+              }
+            }
+            """
+        )
+
+        variables = {
+            "input": input.model_dump(warnings="error", by_alias=True),
+        }
+
+        return self.make_request_and_parse_response(
+            DataResponse[DataResponse[Project]], QUERY, variables
+        ).data.data
+
+    def delete(self, project_id: str) -> bool:
+        QUERY = gql(
+            """
+            mutation ProjectDelete($projectId: String!) {
+              data:projectMutations {
+                data:delete(id: $projectId)
+              }
+            }
+            """
+        )
+
+        variables = {
+            "projectId": project_id,
+        }
+
+        return self.make_request_and_parse_response(
+            DataResponse[DataResponse[bool]], QUERY, variables
+        ).data.data
+
+    def update_role(self, input: ProjectUpdateRoleInput) -> ProjectWithTeam:
+        QUERY = gql(
+            """
+            mutation ProjectUpdateRole($input: ProjectUpdateRoleInput!) {
+              data:projectMutations {
+                data:updateRole(input: $input) {
+                  id
+                  name
+                  description
+                  visibility
+                  allowPublicComments
+                  role
+                  createdAt
+                  updatedAt
+                  sourceApps
+                  workspaceId
+                  team {
+                    id
+                    role
+                    user {
+                      id
+                      name
+                      bio
+                      company
+                      avatar
+                      verified
+                      role
+                    }
+                  }
+                  invitedTeam {
+                    id
+                    inviteId
+                    projectId
+                    projectName
+                    title
+                    role
+                    token
+                    user {
+                      id
+                      name
+                      bio
+                      company
+                      avatar
+                      verified
+                      role
+                    }
+                    invitedBy {
+                      id
+                      name
+                      bio
+                      company
+                      avatar
+                      verified
+                      role
+                    }
+                  }
+                }
+              }
+            }
+            """
+        )
+
+        variables = {
+            "input": input.model_dump(warnings="error", by_alias=True),
+        }
+
+        return self.make_request_and_parse_response(
+            DataResponse[DataResponse[ProjectWithTeam]], QUERY, variables
+        ).data.data

src/specklepy/core/api/resources/current/server_resource.py

@@ -1,20 +1,24 @@
-from typing import Dict, List
+import re
-from gql import gql
+from typing import Any, Dict, List, Tuple
-from gql.client import Client
-from specklepy.api.models import ServerInfo
-from specklepy.api.resource import ResourceBase
 
+from gql import gql
+
+from specklepy.core.api.models import ServerInfo
+from specklepy.core.api.resource import ResourceBase
+from specklepy.logging.exceptions import GraphQLException
 
 NAME = "server"
-METHODS = ["get", "apps"]
 
 
-class Resource(ResourceBase):
+class ServerResource(ResourceBase):
     """API Access class for the server"""
 
-    def __init__(self, me, basepath, client) -> None:
+    def __init__(self, account, basepath, client) -> None:
         super().__init__(
-            me=me, basepath=basepath, client=client, name=NAME, methods=METHODS
+            account=account,
+            basepath=basepath,
+            client=client,
+            name=NAME,
         )
 
     def get(self) -> ServerInfo:
@@ -33,11 +37,6 @@ class Resource(ResourceBase):
                     adminContact
                     canonicalUrl
                     version
-                    roles {
-                        name
-                        description
-                        resourceTarget
-                    }
                     scopes {
                         name
                         description
@@ -47,15 +46,54 @@ class Resource(ResourceBase):
                         name
                         icon
                     }
+                    workspaces {
+                      workspacesEnabled
+                    }
                 }
             }
             """
         )
 
-        return self.make_request(
+        server_info = self.make_request(
             query=query, return_type="serverInfo", schema=ServerInfo
         )
 
+        return server_info
+
+    def version(self) -> Tuple[Any, ...]:
+        """Get the server version
+
+        Returns:
+            the server version in the format (major, minor, patch, (tag, build))
+            eg (2, 6, 3) for a stable build and (2, 6, 4, 'alpha', 4711) for alpha
+        """
+        # not tracking as it will be called along with other mutations / queries
+        # as a check
+        query = gql(
+            """
+            query Server {
+                serverInfo {
+                    version
+                }
+            }
+            """
+        )
+        ver = self.make_request(
+            query=query, return_type=["serverInfo", "version"], parse_response=False
+        )
+        if isinstance(ver, Exception):
+            raise GraphQLException(
+                f"Could not get server version for {self.basepath}", [ver]
+            )
+
+        # pylint: disable=consider-using-generator; (list comp is faster)
+        return tuple(
+            [
+                int(segment) if segment.isdigit() else segment
+                for segment in re.split(r"\.|-", ver)
+            ]
+        )
+
     def apps(self) -> Dict:
         """Get the apps registered on the server
 

src/specklepy/core/api/resources/current/subscription_resource.py

@@ -0,0 +1,218 @@
+from functools import wraps
+from typing import Any, Callable, Dict, Optional, Sequence, Type
+
+from gql import gql
+from graphql import DocumentNode
+from pydantic import BaseModel
+from typing_extensions import TypeVar
+
+from specklepy.core.api.models import (
+    ProjectModelsUpdatedMessage,
+    ProjectUpdatedMessage,
+    ProjectVersionsUpdatedMessage,
+    UserProjectsUpdatedMessage,
+)
+from specklepy.core.api.resource import ResourceBase
+from specklepy.core.api.responses import DataResponse
+from specklepy.logging.exceptions import SpeckleException
+
+NAME = "subscribe"
+
+TEventArgs = TypeVar("TEventArgs", bound=BaseModel)
+
+
+def check_wsclient(function):
+    @wraps(function)
+    async def check_wsclient_wrapper(self, *args, **kwargs):
+        if self.client is None:
+            raise SpeckleException(
+                "You must authenticate before you can subscribe to events"
+            )
+        else:
+            return await function(self, *args, **kwargs)
+
+    return check_wsclient_wrapper
+
+
+class SubscriptionResource(ResourceBase):
+    """API Access class for subscriptions"""
+
+    def __init__(self, account, basepath, client) -> None:
+        super().__init__(
+            account=account,
+            basepath=basepath,
+            client=client,
+            name=NAME,
+        )
+
+    async def user_projects_updated(
+        self, callback: Callable[[UserProjectsUpdatedMessage], None]
+    ) -> None:
+        QUERY = gql(
+            """
+            subscription UserProjectsUpdated {
+              data:userProjectsUpdated {
+                id
+                project {
+                  id
+                  name
+                  description
+                  visibility
+                  allowPublicComments
+                  role
+                  createdAt
+                  updatedAt
+                  sourceApps
+                  workspaceId
+                }
+                type
+              }
+            }
+            """
+        )
+
+        await self.subscribe_2(
+            DataResponse[UserProjectsUpdatedMessage],
+            QUERY,
+            None,
+            callback=lambda d: callback(d.data),
+        )
+
+    async def project_models_updated(
+        self,
+        callback: Callable[[ProjectModelsUpdatedMessage], None],
+        id: str,
+        model_ids: Optional[Sequence[str]] = None,
+    ) -> None:
+        QUERY = gql(
+            """
+            subscription ProjectModelsUpdated($id: String!, $modelIds: [String!]) {
+              data:projectModelsUpdated(id: $id, modelIds: $modelIds) {
+                id
+                model {
+                  id
+                  name
+                  previewUrl
+                  updatedAt
+                  description
+                  displayName
+                  createdAt
+                  author {
+                    avatar
+                    bio
+                    company
+                    id
+                    name
+                    role
+                    verified
+                  }
+                }
+                type
+              }
+            }
+            """
+        )
+
+        variables = {"id": id, "modelIds": model_ids}
+
+        await self.subscribe_2(
+            DataResponse[ProjectModelsUpdatedMessage],
+            QUERY,
+            variables,
+            callback=lambda d: callback(d.data),
+        )
+
+    async def project_updated(
+        self,
+        callback: Callable[[ProjectUpdatedMessage], None],
+        id: str,
+    ) -> None:
+        QUERY = gql(
+            """
+            subscription ProjectUpdated($id: String!) {
+              data:projectUpdated(id: $id) {
+                id
+                project {
+                  id
+                  name
+                  description
+                  visibility
+                  allowPublicComments
+                  role
+                  createdAt
+                  updatedAt
+                  sourceApps
+                  workspaceId
+                }
+                type
+              }
+            }
+            """
+        )
+
+        variables = {"id": id}
+
+        await self.subscribe_2(
+            DataResponse[ProjectUpdatedMessage],
+            QUERY,
+            variables,
+            callback=lambda d: callback(d.data),
+        )
+
+    async def project_versions_updated(
+        self,
+        callback: Callable[[ProjectVersionsUpdatedMessage], None],
+        id: str,
+    ) -> None:
+        QUERY = gql(
+            """
+            subscription ProjectVersionsUpdated($id: String!) {
+              data:projectVersionsUpdated(id: $id) {
+                id
+                modelId
+                type
+                version {
+                  id
+                  referencedObject
+                  message
+                  sourceApplication
+                  createdAt
+                  previewUrl
+                  authorUser {
+                    id
+                    name
+                    bio
+                    company
+                    verified
+                    role
+                    avatar
+                  }
+                }
+              }
+            }
+            """
+        )
+
+        variables = {"id": id}
+
+        await self.subscribe_2(
+            DataResponse[ProjectVersionsUpdatedMessage],
+            QUERY,
+            variables,
+            callback=lambda d: callback(d.data),
+        )
+
+    @check_wsclient
+    async def subscribe_2(
+        self,
+        response_type: Type[TEventArgs],
+        query: DocumentNode,
+        variables: Optional[Dict[str, Any]],
+        callback: Callable[[TEventArgs], None],
+    ) -> None:
+        async with self.client as session:
+            self.session = session
+            gen = session.subscribe(query, variable_values=variables)
+            async for res in gen:
+                event_arg = response_type.model_validate(res)
+                callback(event_arg)

src/specklepy/core/api/resources/current/version_resource.py

@@ -0,0 +1,255 @@
+from typing import Optional
+
+from gql import gql
+
+from specklepy.core.api.inputs.model_inputs import ModelVersionsFilter
+from specklepy.core.api.inputs.version_inputs import (
+    CreateVersionInput,
+    DeleteVersionsInput,
+    MarkReceivedVersionInput,
+    MoveVersionsInput,
+    UpdateVersionInput,
+)
+from specklepy.core.api.models import ResourceCollection, Version
+from specklepy.core.api.resource import ResourceBase
+from specklepy.core.api.responses import DataResponse
+
+NAME = "model"
+
+
+class VersionResource(ResourceBase):
+    """API Access class for model versions"""
+
+    def __init__(self, account, basepath, client, server_version) -> None:
+        super().__init__(
+            account=account,
+            basepath=basepath,
+            client=client,
+            name=NAME,
+            server_version=server_version,
+        )
+
+    def get(self, version_id: str, project_id: str) -> Version:
+        QUERY = gql(
+            """
+            query VersionGet($projectId: String!, $versionId: String!) {
+              data:project(id: $projectId) {
+                data:version(id: $versionId) {
+                  id
+                  referencedObject
+                  message
+                  sourceApplication
+                  createdAt
+                  previewUrl
+                  authorUser {
+                    id
+                    name
+                    bio
+                    company
+                    verified
+                    role
+                    avatar
+                  }
+                }
+              }
+            }
+            """
+        )
+
+        variables = {
+            "projectId": project_id,
+            "versionId": version_id,
+        }
+
+        return self.make_request_and_parse_response(
+            DataResponse[DataResponse[Version]], QUERY, variables
+        ).data.data
+
+    def get_versions(
+        self,
+        model_id: str,
+        project_id: str,
+        *,
+        limit: int = 25,
+        cursor: Optional[str] = None,
+        filter: Optional[ModelVersionsFilter] = None,
+    ) -> ResourceCollection[Version]:
+        QUERY = gql(
+            """
+            query VersionGetVersions(
+              $projectId: String!,
+              $modelId: String!,
+              $limit: Int!,
+              $cursor: String,
+              $filter: ModelVersionsFilter
+              ) {
+              data:project(id: $projectId) {
+                data:model(id: $modelId) {
+                  data:versions(limit: $limit, cursor: $cursor, filter: $filter) {
+                    items {
+                      id
+                      referencedObject
+                      message
+                      sourceApplication
+                      createdAt
+                      previewUrl
+                      authorUser {
+                        id
+                        name
+                        bio
+                        company
+                        verified
+                        role
+                        avatar
+                      }
+                    }
+                    cursor
+                    totalCount
+                  }
+                }
+              }
+            }
+            """
+        )
+
+        variables = {
+            "projectId": project_id,
+            "modelId": model_id,
+            "limit": limit,
+            "cursor": cursor,
+            "filter": (
+                filter.model_dump(warnings="error", by_alias=True) if filter else None
+            ),
+        }
+
+        return self.make_request_and_parse_response(
+            DataResponse[DataResponse[DataResponse[ResourceCollection[Version]]]],
+            QUERY,
+            variables,
+        ).data.data.data
+
+    def create(self, input: CreateVersionInput) -> Version:
+        QUERY = gql(
+            """
+            mutation Create($input: CreateVersionInput!) {
+              data:versionMutations {
+                data:create(input: $input) {
+                  id
+                  referencedObject
+                  message
+                  sourceApplication
+                  createdAt
+                  previewUrl
+                  authorUser {
+                    id
+                    name
+                    bio
+                    company
+                    verified
+                    role
+                    avatar
+                  }
+                }
+              }
+            }
+            """
+        )
+        variables = {
+            "input": input.model_dump(warnings="error", by_alias=True),
+        }
+
+        return self.make_request_and_parse_response(
+            DataResponse[DataResponse[Version]], QUERY, variables
+        ).data.data
+
+    def update(self, input: UpdateVersionInput) -> Version:
+        QUERY = gql(
+            """
+            mutation VersionUpdate($input: UpdateVersionInput!) {
+              data:versionMutations {
+                data:update(input: $input) {
+                  id
+                  referencedObject
+                  message
+                  sourceApplication
+                  createdAt
+                  previewUrl
+                  authorUser {
+                    id
+                    name
+                    bio
+                    company
+                    verified
+                    role
+                    avatar
+                  }
+                }
+              }
+            }
+            """
+        )
+
+        variables = {"input": input.model_dump(warnings="error", by_alias=True)}
+
+        return self.make_request_and_parse_response(
+            DataResponse[DataResponse[Version]], QUERY, variables
+        ).data.data
+
+    def move_to_model(self, input: MoveVersionsInput) -> str:
+        QUERY = gql(
+            """
+            mutation VersionMoveToModel($input: MoveVersionsInput!) {
+              data:versionMutations {
+                data:moveToModel(input: $input) {
+                  data:id
+                }
+              }
+            }
+            """
+        )
+
+        variables = {
+            "input": input.model_dump(warnings="error", by_alias=True),
+        }
+
+        return self.make_request_and_parse_response(
+            DataResponse[DataResponse[DataResponse[str]]], QUERY, variables
+        ).data.data.data
+
+    def delete(self, input: DeleteVersionsInput) -> bool:
+        QUERY = gql(
+            """
+            mutation VersionDelete($input: DeleteVersionsInput!) {
+              data:versionMutations {
+                data:delete(input: $input)
+              }
+            }
+            """
+        )
+
+        variables = {
+            "input": input.model_dump(warnings="error", by_alias=True),
+        }
+
+        return self.make_request_and_parse_response(
+            DataResponse[DataResponse[bool]], QUERY, variables
+        ).data.data
+
+    def received(self, input: MarkReceivedVersionInput) -> bool:
+        QUERY = gql(
+            """
+            mutation MarkReceived($input: MarkReceivedVersionInput!) {
+              data:versionMutations {
+                data:markReceived(input: $input)
+              }
+            }
+            """
+        )
+
+        variables = {
+            "input": input.model_dump(warnings="error", by_alias=True),
+        }
+
+        return self.make_request_and_parse_response(
+            DataResponse[DataResponse[bool]], QUERY, variables
+        ).data.data

src/specklepy/core/api/resources/current/workspace_resource.py

@@ -0,0 +1,180 @@
+from typing import Optional
+
+from gql import gql
+
+from specklepy.core.api.inputs.project_inputs import WorksaceProjectsFilter
+from specklepy.core.api.models.current import (
+    Project,
+    ProjectWithPermissions,
+    ResourceCollection,
+    Workspace,
+)
+from specklepy.core.api.resource import ResourceBase
+from specklepy.core.api.responses import DataResponse
+
+NAME = "workspace"
+
+
+class WorkspaceResource(ResourceBase):
+    """API Access class for models"""
+
+    def __init__(self, account, basepath, client, server_version) -> None:
+        super().__init__(
+            account=account,
+            basepath=basepath,
+            client=client,
+            name=NAME,
+            server_version=server_version,
+        )
+
+    def get(self, workspace_id: str) -> Workspace:
+        QUERY = gql(
+            """
+            query WorkspaceGet($workspaceId: String!) {
+              data:workspace(id: $workspaceId) {
+                id
+                name
+                role
+                slug
+                logo
+                createdAt
+                updatedAt
+                readOnly
+                description
+                creationState
+                {
+                  completed
+                }
+                permissions {
+                  canCreateProject {
+                    authorized
+                    code
+                    message
+                  }
+                }
+              }
+            }
+            """
+        )
+
+        variables = {
+            "workspaceId": workspace_id,
+        }
+
+        return self.make_request_and_parse_response(
+            DataResponse[Workspace], QUERY, variables
+        ).data
+
+    def get_projects(
+        self,
+        workspace_id: str,
+        limit: int = 25,
+        cursor: Optional[str] = None,
+        filter: Optional[WorksaceProjectsFilter] = None,
+    ) -> ResourceCollection[Project]:
+        QUERY = gql(
+            """
+            query Workspace($workspaceId: String!, $limit: Int!, $cursor: String, $filter: WorkspaceProjectsFilter) {
+              data:workspace(id: $workspaceId) {
+                data:projects(limit: $limit, cursor: $cursor, filter: $filter) {
+                  cursor
+                  items {
+                    allowPublicComments
+                    createdAt
+                    description
+                    id
+                    name
+                    role
+                    sourceApps
+                    updatedAt
+                    visibility
+                    workspaceId
+                  }
+                  totalCount
+                }
+              }
+            }
+            """  # noqa: E501
+        )
+
+        variables = {
+            "workspaceId": workspace_id,
+            "limit": limit,
+            "cursor": cursor,
+            "filter": filter.model_dump(warnings="error", by_alias=True)
+            if filter
+            else None,
+        }
+
+        return self.make_request_and_parse_response(
+            DataResponse[DataResponse[ResourceCollection[Project]]], QUERY, variables
+        ).data.data
+
+    def get_projects_with_permissions(
+        self,
+        workspace_id: str,
+        limit: int = 25,
+        cursor: Optional[str] = None,
+        filter: Optional[WorksaceProjectsFilter] = None,
+    ) -> ResourceCollection[ProjectWithPermissions]:
+        QUERY = gql(
+            """
+            query Workspace($workspaceId: String!, $limit: Int!, $cursor: String, $filter: WorkspaceProjectsFilter) {
+              data:workspace(id: $workspaceId) {
+                data:projects(limit: $limit, cursor: $cursor, filter: $filter) {
+                  cursor
+                  items {
+                    allowPublicComments
+                    createdAt
+                    description
+                    id
+                    name
+                    role
+                    sourceApps
+                    updatedAt
+                    visibility
+                    workspaceId
+                    permissions {
+                      canCreateModel {
+                        code
+                        authorized
+                        message
+                      }
+                      canDelete {
+                        code
+                        authorized
+                        message
+                      }
+                      canLoad {
+                        code
+                        authorized
+                        message
+                      }
+                      canPublish {
+                        code
+                        authorized
+                        message
+                      }
+                    }
+                  }
+                  totalCount
+                }
+              }
+            }
+            """  # noqa: E501
+        )
+
+        variables = {
+            "workspaceId": workspace_id,
+            "limit": limit,
+            "cursor": cursor,
+            "filter": filter.model_dump(warnings="error", by_alias=True)
+            if filter
+            else None,
+        }
+
+        return self.make_request_and_parse_response(
+            DataResponse[DataResponse[ResourceCollection[ProjectWithPermissions]]],
+            QUERY,
+            variables,
+        ).data.data

src/specklepy/core/api/resources/graphql.config.yml

@@ -0,0 +1,2 @@
+schema: https://app.speckle.systems/graphql
+documents: '**/*.graphql'

src/specklepy/core/api/responses.py

@@ -0,0 +1,9 @@
+from typing import Generic, TypeVar
+
+from pydantic import BaseModel
+
+T = TypeVar("T")
+
+
+class DataResponse(BaseModel, Generic[T]):
+    data: T