re-lock

* First Pass

* Updated traversal

---------

Co-authored-by: KatKatKateryna <89912278+KatKatKateryna@users.noreply.github.com>

.circleci/config.yml

@@ -1,70 +1,15 @@
 version: 2.1
 
-orbs:
-  python: circleci/python@2.0.3
-  codecov: codecov/codecov@3.2.2
-
+# Define the jobs we want to run for this project
 jobs:
-  test:
-    machine:
-      image: ubuntu-2204:2023.02.1
-      docker_layer_caching: false
-    resource_class: medium
-    parameters:
-      tag:
-        default: "3.11"
-        type: string
-    steps:
-      - checkout
-      - run:
-          name: Install python
-          command: |
-            pyenv install -s << parameters.tag >>
-            pyenv global << parameters.tag >>
-      - run:
-          name: Startup the Speckle Server
-          command: docker compose -f docker-compose.yml up -d
-      - run:
-          name: Install Poetry
-          command: |
-            pip install poetry
-      - run:
-          name: Install packages
-          command: poetry install
-      - run:
-          name: Run tests
-          command: 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:
+  build:
     docker:
-      - image: "cimg/python:3.8"
+      - image: cimg/base:2023.03
     steps:
-      - checkout
-      - run: python patch_version.py $CIRCLE_TAG
-      - run: poetry build
-      - run: poetry publish -u __token__ -p $PYPI_TOKEN
+      - run: echo "so long and thanks for all the fish"
 
+# Orchestrate our job run sequence
 workflows:
-  main:
+  build_and_test:
     jobs:
-      - test:
-          matrix:
-            parameters:
-              tag: ["3.11"]
-          filters:
-            tags:
-              only: /.*/
-      - deploy:
-          context: pypi
-          requires:
-            - test
-          filters:
-            tags:
-              only: /[0-9]+(\.[0-9]+)*/
-            branches:
-              ignore: /.*/ # For testing only! /ci\/.*/
+      - build

.devcontainer/Dockerfile

@@ -22,6 +22,6 @@ RUN if [ "${NODE_VERSION}" != "none" ]; then su vscode -c "umask 0002 && . /usr/
 
 USER vscode
 
-RUN curl -sSL https://raw.githubusercontent.com/python-poetry/poetry/master/get-poetry.py | python -
+RUN curl -sSL https://install.python-poetry.org | python3 -
 
 ENV PATH=$PATH:$HOME/.poetry/env

.github/workflows/github-action.yml

@@ -0,0 +1,56 @@
+name: "Specklepy test and build"
+on:
+  # pull_request:
+  #   branches:
+  #     - 'v3-dev'
+  push:
+    branches:
+      - "gergo/uvSetup"
+jobs:
+  ci:
+    name: continuous-integration
+    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 -d
+
+      # - 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,36 @@
+# Publish a release to PyPI.
+# name: 'Publish to PyPI'
+
+# on:
+  # push:
+  #   branches:
+  #     - 'gergo/uvSetup'
+
+# jobs:
+#   pypi-publish:
+#     name: Upload to PyPI
+#     runs-on: ubuntu-latest
+#     environment:
+#       name: release
+#     permissions:
+#       # For PyPI's trusted publishing.
+#       id-token: write
+#     steps:
+#       - name: 'Install uv'
+#         uses: astral-sh/setup-uv@v5
+#       - uses: actions/checkout@v4
+#         with:
+#           # This is necessary so that we have the tags.
+#           fetch-depth: 0
+#       - uses: mtkennerly/dunamai-action@v1
+#         with:
+#           env-var: MY_VERSION
+#           args: --style semver
+#       - run: echo $MY_VERSION
+#       - name: 'Build artifacts'
+#         run: uv build
+#       - name: Publish to PyPi
+#         run: uv publish --publish-url https://test.pypi.org/simple/
+
+#       - name: Test package install
+#         run: uv run --with specklepy --no-project -- python -c "import specklepy"

.pre-commit-config.yaml

@@ -1,33 +1,31 @@
 repos:
-  - repo: https://github.com/charliermarsh/ruff-pre-commit
+  - repo: local
     hooks:
+      # Run the linter.
       - id: ruff
-    rev: v0.0.186
+        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:
-      - push
-    rev: v2.38.0
+      - id: commitizen
+      - id: commitizen-branch
+        stages:
+          - pre-push
+    rev: v3.13.0
 
-  - repo: https://github.com/pycqa/isort
-    rev: v5.11.3
-    hooks:
-      - id: isort
 
-  - repo: https://github.com/psf/black
-    rev: 22.12.0
-    hooks:
-      - id: black
-        # It is recommended to specify the latest version of Python
-        # supported by your project here, or alternatively use
-        # pre-commit's default_language_version, see
-        # https://pre-commit.com/#top_level-default_language_version
-        # language_version: python3.11
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.4.0
+    rev: v5.0.0
     hooks:
       - id: end-of-file-fixer
       - id: trailing-whitespace

.vscode/launch.json

@@ -4,11 +4,9 @@
   // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
   "version": "0.2.0",
   "configurations": [
-
-
     {
       "name": "Python: Current File",
-      "type": "python",
+      "type": "debugpy",
       "request": "launch",
       "program": "${file}",
       "console": "integratedTerminal",
@@ -16,9 +14,9 @@
     },
     {
       "name": "Pytest",
-      "type": "python",
+      "type": "debugpy",
       "request": "launch",
-      "program": "pytest",
+      "module": "pytest",
       "args": [],
       "console": "integratedTerminal",
       "justMyCode": true

README.md

@@ -2,46 +2,16 @@
   <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
 
@@ -55,25 +25,25 @@ 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. Poetry 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. Uv 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.
+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`

docker-compose.yml

@@ -6,7 +6,7 @@ services:
   # Speckle Server dependencies
   #######
   postgres:
-    image: "postgres:14.5-alpine"
+    image: "postgres:16-alpine"
     restart: always
     environment:
       POSTGRES_DB: speckle
@@ -52,28 +52,20 @@ services:
   ####
   # Speckle Server
   #######
-  speckle-frontend:
-    image: speckle/speckle-frontend:latest
-    restart: always
-    ports:
-      - "0.0.0.0:8080:8080"
-    environment:
-      FILE_SIZE_LIMIT_MB: 100
 
   speckle-server:
     image: speckle/speckle-server:latest
     restart: always
     healthcheck:
       test:
-        [
-          "CMD",
-          "node",
-          "-e",
-          "require('node:http').request({headers: {'Content-Type': 'application/json'}, port:3000, hostname:'127.0.0.1', path:'/graphql?query={serverInfo{version}}', method: 'GET' }, (res) => { body = ''; res.on('data', (chunk) => {body += chunk;}); res.on('end', () => {process.exit(res.statusCode != 200 || body.toLowerCase().includes('error'));}); }).end();",
-        ]
+        - 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: 3s
-      retries: 30
+      timeout: 10s
+      retries: 3
+      start_period: 90s
     ports:
       - "0.0.0.0:3000:3000"
     depends_on:
@@ -98,6 +90,7 @@ services:
       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"
@@ -111,47 +104,6 @@ services:
       POSTGRES_DB: "speckle"
       ENABLE_MP: "false"
 
-  preview-service:
-    image: speckle/speckle-preview-service:latest
-    restart: always
-    depends_on:
-      speckle-server:
-        condition: service_healthy
-    mem_limit: "1000m"
-    memswap_limit: "1000m"
-    environment:
-      DEBUG: "preview-service:*"
-      PG_CONNECTION_STRING: "postgres://speckle:speckle@postgres/speckle"
-
-  webhook-service:
-    image: speckle/speckle-webhook-service:latest
-    restart: always
-    depends_on:
-      speckle-server:
-        condition: service_healthy
-    environment:
-      DEBUG: "webhook-service:*"
-      PG_CONNECTION_STRING: "postgres://speckle:speckle@postgres/speckle"
-      WAIT_HOSTS: postgres:5432
-
-  fileimport-service:
-    image: speckle/speckle-fileimport-service:latest
-    restart: always
-    depends_on:
-      speckle-server:
-        condition: service_healthy
-    environment:
-      DEBUG: "fileimport-service:*"
-      PG_CONNECTION_STRING: "postgres://speckle:speckle@postgres/speckle"
-      WAIT_HOSTS: postgres:5432
-
-      S3_ENDPOINT: "http://minio:9000"
-      S3_ACCESS_KEY: "minioadmin"
-      S3_SECRET_KEY: "minioadmin"
-      S3_BUCKET: "speckle-server"
-
-      SPECKLE_SERVER_URL: "http://speckle-server:3000"
-
 networks:
   default:
     name: speckle-server

example/units_none.py

@@ -1,8 +1,8 @@
 from devtools import debug
 
 from specklepy.api import operations
-from specklepy.objects.geometry import Base
-from specklepy.objects.units import Units
+from specklepy.objects_v2.geometry import Base
+from specklepy.objects_v2.units import Units
 
 dct = {
     "id": "1234abcd",

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("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,73 +1,70 @@
-[tool.poetry]
+[project]
+dynamic = ["version"]
 name = "specklepy"
-version = "2.17.8"
 description = "The Python SDK for Speckle 2.0"
 readme = "README.md"
-authors = ["Speckle Systems <devops@speckle.systems>"]
-license = "Apache-2.0"
-repository = "https://github.com/specklesystems/speckle-py"
-documentation = "https://speckle.guide/dev/py-examples.html"
-homepage = "https://speckle.systems/"
-packages = [
-  { include = "specklepy", from = "src" },
-  { include = "speckle_automate", from = "src" },
+authors = [{ name = "Speckle Systems", email = "devops@speckle.systems" }]
+license = { text = "Apache-2.0" }
+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",
+  "stringcase>=1.2.0",
+  "ujson>=5.10.0",
 ]
 
+[dependency-groups]
+dev = [
+  "commitizen>=4.1.0",
+  "devtools>=0.12.2",
+  "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",
+]
 
-[tool.poetry.dependencies]
-python = ">=3.8.0, <4.0"
-pydantic = "^2.0"
-appdirs = "^1.4.4"
-gql = {extras = ["requests", "websockets"], version = "^3.3.0"}
-ujson = "^5.3.0"
-Deprecated = "^1.2.13"
-stringcase = "^1.2.0"
-attrs = "^23.1.0"
-httpx = "^0.25.0"
+[project.urls]
+repository = "https://github.com/specklesystems/specklepy"
+documentation = "https://speckle.guide/dev/py-examples.html"
+homepage = "https://speckle.systems/"
 
-[tool.poetry.group.dev.dependencies]
-black = "^22.8.0"
-isort = "^5.7.0"
-pytest = "^7.1.3"
-pytest-ordering = "^0.6"
-pytest-cov = "^3.0.0"
-devtools = "^0.8.0"
-pylint = "^2.14.4"
-mypy = "^0.982"
-pre-commit = "^2.20.0"
-commitizen = "^2.38.0"
-ruff = "^0.0.187"
-types-deprecated = "^1.2.9"
-types-ujson = "^5.6.0.0"
-types-requests = "^2.28.11.5"
-
-[tool.black]
-exclude = '''
-/(
-    \.eggs
-  | \.git
-  | \.hg
-  | \.mypy_cache
-  | \.tox
-  | \.venv
-  | _build
-  | buck-out
-  | build
-  | dist
-)/
-'''
-include = '\.pyi?$'
-line-length = 88
-target-version = ["py37", "py38", "py39", "py310", "py311"]
+[build-system]
+requires = ["setuptools>=64", "setuptools-scm>=8"]
+build-backend = "setuptools.build_meta"
 
+[tool.setuptools_scm]
 
 [tool.commitizen]
 name = "cz_conventional_commits"
 version = "2.9.2"
 tag_format = "$version"
-[build-system]
-requires = ["poetry-core>=1.0.0"]
-build-backend = "poetry.core.masonry.api"
 
-[tool.isort]
-profile = "black"
+[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"]

src/speckle_automate/__init__.py

@@ -1,4 +1,5 @@
 """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 (

src/speckle_automate/automation_context.py

@@ -1,18 +1,12 @@
 """This module provides an abstraction layer above the Speckle Automate runtime."""
+
+import time
 from dataclasses import dataclass, field
 from pathlib import Path
-import time
 from typing import Any, Dict, List, Optional, Tuple, Union
 
 import httpx
 from gql import gql
-from specklepy.api import operations
-from specklepy.api.client import SpeckleClient
-from specklepy.core.api.models import Branch
-from specklepy.objects import Base
-from specklepy.transports.memory import MemoryTransport
-from specklepy.transports.server import ServerTransport
-from specklepy.logging.exceptions import SpeckleException
 
 from speckle_automate.schema import (
     AutomateBase,
@@ -22,6 +16,13 @@ from speckle_automate.schema import (
     ObjectResultLevel,
     ResultCase,
 )
+from specklepy.api import operations
+from specklepy.api.client import SpeckleClient
+from specklepy.core.api.models import Branch
+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
@@ -95,17 +96,29 @@ class AutomationContext:
 
     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
         commit = self.speckle_client.commit.get(
-            self.automation_run_data.project_id, self.automation_run_data.version_id
+            self.automation_run_data.project_id, version_id
         )
-        if not commit.referencedObject:
-            raise ValueError("The commit has no referencedObject, cannot receive it.")
+        if not commit or not commit.referencedObject:
+            raise ValueError(
+                f"""\
+                             Could not receive specified version.
+                             {"The commit has no referencedObject." if not commit.referencedObject else ""}
+                             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}
+                             """
+            )
         base = operations.receive(
             commit.referencedObject, self._server_transport, self._memory_transport
         )
         print(
             f"It took {self.elapsed():.2f} seconds to receive",
-            f" the speckle version {self.automation_run_data.version_id}",
+            f" the speckle version {version_id}",
         )
         return base
 
@@ -120,19 +133,27 @@ class AutomationContext:
             version_message (str): The message for the new version.
         """
 
-        if model_name == self.automation_run_data.branch_name:
-            raise ValueError(
-                f"The target model: {model_name} cannot match the model"
-                f" that triggered this automation:"
-                f" {self.automation_run_data.model_id} /"
-                f" {self.automation_run_data.branch_name}"
-            )
-
         branch = self.speckle_client.branch.get(
             self.automation_run_data.project_id, model_name, 1
         )
-        # we just check if it exists
-        if (not branch) or isinstance(branch, SpeckleException):
+        if isinstance(branch, Branch):
+            if not branch.id:
+                raise ValueError("Cannot use the branch without its id")
+            matching_trigger = [
+                t
+                for t in self.automation_run_data.triggers
+                if t.payload.model_id == branch.id
+            ]
+            if matching_trigger:
+                raise ValueError(
+                    f"The target model: {model_name} cannot match the model"
+                    f" that triggered this automation:"
+                    f" {matching_trigger[0].payload.model_id}"
+                )
+            model_id = branch.id
+
+        else:
+            # we just check if it exists
             branch_create = self.speckle_client.branch.create(
                 self.automation_run_data.project_id,
                 model_name,
@@ -140,8 +161,6 @@ class AutomationContext:
             if isinstance(branch_create, Exception):
                 raise branch_create
             model_id = branch_create
-        else:
-            model_id = branch.id
 
         root_object_id = operations.send(
             root_object,
@@ -175,7 +194,8 @@ class AutomationContext:
     ) -> None:
         link_resources = (
             [
-                f"{self.automation_run_data.model_id}@{self.automation_run_data.version_id}"
+                f"{t.payload.model_id}@{t.payload.version_id}"
+                for t in self.automation_run_data.triggers
             ]
             if include_source_model_version
             else []
@@ -195,47 +215,28 @@ class AutomationContext:
         """Report the current run status to the project of this automation."""
         query = gql(
             """
-            mutation ReportFunctionRunStatus(
-                $automationId: String!, 
-                $automationRevisionId: String!, 
-                $automationRunId: String!,
-                $versionId: String!,
-                $functionId: String!,
-                $functionName: String!,
-                $functionLogo: String,
-                $runStatus: AutomationRunStatus!
-                $elapsed: Float!
-                $contextView: String
-                $resultVersionIds: [String!]!
+            mutation AutomateFunctionRunStatusReport(
+                $projectId: String!
+                $functionRunId: String!
+                $status: AutomateRunStatus!
                 $statusMessage: String
-                $objectResults: JSONObject
+                $results: JSONObject
+                $contextView: String
             ){
-                automationMutations {
-                    functionRunStatusReport(input: {
-                        automationId: $automationId
-                        automationRevisionId: $automationRevisionId
-                        automationRunId: $automationRunId
-                        versionId: $versionId
-                        functionRuns: [
-                        {
-                            functionId: $functionId
-                            functionName: $functionName
-                            functionLogo: $functionLogo
-                            status: $runStatus,
-                            contextView: $contextView,
-                            elapsed: $elapsed,
-                            resultVersionIds: $resultVersionIds,
-                            statusMessage: $statusMessage
-                            results: $objectResults
-                        }]
-                   })
-                }
+                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": "1.0.0",
+                "version": 1,
                 "values": {
                     "objectResults": self._automation_result.model_dump(by_alias=True)[
                         "objectResults"
@@ -247,19 +248,12 @@ class AutomationContext:
             object_results = None
 
         params = {
-            "automationId": self.automation_run_data.automation_id,
-            "automationRevisionId": self.automation_run_data.automation_revision_id,
-            "automationRunId": self.automation_run_data.automation_run_id,
-            "versionId": self.automation_run_data.version_id,
-            "functionId": self.automation_run_data.function_id,
-            "functionName": self.automation_run_data.function_name,
-            "functionLogo": self.automation_run_data.function_logo,
-            "runStatus": self.run_status.value,
+            "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,
-            "elapsed": self.elapsed(),
-            "resultVersionIds": self._automation_result.result_versions,
-            "objectResults": object_results,
         }
         print(f"Reporting run status with content: {params}")
         self.speckle_client.httpclient.execute(query, params)
@@ -280,10 +274,11 @@ class AutomationContext:
 
         if not path_obj.exists():
             raise ValueError("The given file path doesn't exist")
-        files = {path_obj.name: open(str(path_obj), "rb")}
+
+        files = {path_obj.name: path_obj.open("rb")}
 
         url = (
-            f"{self.automation_run_data.speckle_server_url}/api/stream/"
+            f"{self.automation_run_data.speckle_server_url}api/stream/"
             f"{self.automation_run_data.project_id}/blob"
         )
         data = (
@@ -309,6 +304,10 @@ class AutomationContext:
         """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)
@@ -370,6 +369,24 @@ class AutomationContext:
             visual_overrides,
         )
 
+    def attach_success_to_objects(
+        self,
+        category: str,
+        object_ids: Union[str, List[str]],
+        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."""
+        self.attach_result_to_objects(
+            ObjectResultLevel.SUCCESS,
+            category,
+            object_ids,
+            message,
+            metadata,
+            visual_overrides,
+        )
+
     def attach_info_to_objects(
         self,
         category: str,

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/helpers.py

@@ -1,54 +0,0 @@
-"""Some useful helpers for working with automation data."""
-import secrets
-import string
-
-from specklepy.api.client import SpeckleClient
-from gql import gql
-
-
-def register_new_automation(
-    speckle_client: SpeckleClient,
-    project_id: str,
-    model_id: str,
-    automation_id: str,
-    automation_name: str,
-    automation_revision_id: str,
-) -> bool:
-    """Register a new automation in the speckle server."""
-    query = gql(
-        """
-        mutation CreateAutomation(
-            $projectId: String! 
-            $modelId: String! 
-            $automationName: String!
-            $automationId: String! 
-            $automationRevisionId: String!
-        ) {
-                automationMutations {
-                    create(
-                        input: {
-                            projectId: $projectId
-                            modelId: $modelId
-                            automationName: $automationName 
-                            automationId: $automationId
-                            automationRevisionId: $automationRevisionId
-                        }
-                    )
-                }
-            }
-        """
-    )
-    params = {
-        "projectId": project_id,
-        "modelId": model_id,
-        "automationName": automation_name,
-        "automationId": automation_id,
-        "automationRevisionId": automation_revision_id,
-    }
-    return speckle_client.httpclient.execute(query, params)
-
-
-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()

src/speckle_automate/runner.py

@@ -3,12 +3,15 @@
 Provides mechanisms to execute any function,
  that conforms to the AutomateFunction "interface"
 """
+
 import json
-import os
 import sys
 import traceback
 from pathlib import Path
-from typing import Callable, Optional, TypeVar, Union, overload
+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
@@ -19,17 +22,59 @@ 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:
-    ...
+) -> None: ...
 
 
 @overload
-def execute_automate_function(automate_function: AutomateFunctionWithoutInputs) -> None:
-    ...
+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(
@@ -40,56 +85,54 @@ def execute_automate_function(
     # first arg is the python file name, we do not need that
     args = sys.argv[1:]
 
-    if len(args) < 2:
-        raise ValueError("too few arguments specified need minimum 2")
-
-    if len(args) > 4:
-        raise ValueError("too many arguments specified, max supported is 4")
+    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 = args[0]
+    command, argument = args
 
     if command == "generate_schema":
-        path = Path(args[1])
+        path = Path(argument)
         schema = json.dumps(
-            input_schema.model_json_schema(by_alias=True) if input_schema else {}
+            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 = args[1]
-        function_inputs = args[2]
+        automation_run_data, function_inputs, speckle_token = _parse_input_data(
+            argument, input_schema
+        )
 
-        speckle_token = os.environ.get("SPECKLE_TOKEN", None)
-        if not speckle_token and len(args) != 4:
-            raise ValueError("Cannot get speckle token from arguments or environment")
-
-        speckle_token = speckle_token if speckle_token else args[3]
         automation_context = AutomationContext.initialize(
             automation_run_data, speckle_token
         )
 
-        inputs = (
-            input_schema.model_validate_json(function_inputs)
-            if input_schema
-            else input_schema
-        )
-
-        if inputs:
+        if function_inputs:
             automation_context = run_function(
                 automation_context,
                 automate_function,  # type: ignore
-                inputs,
+                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 = (
-            0 if automation_context.run_status == AutomationStatus.SUCCEEDED else 1
+            1 if automation_context.run_status == AutomationStatus.EXCEPTION else 0
         )
         exit(exit_code)
 
@@ -102,16 +145,14 @@ def run_function(
     automation_context: AutomationContext,
     automate_function: AutomateFunction[T],
     inputs: T,
-) -> AutomationContext:
-    ...
+) -> AutomationContext: ...
 
 
 @overload
 def run_function(
     automation_context: AutomationContext,
     automate_function: AutomateFunctionWithoutInputs,
-) -> AutomationContext:
-    ...
+) -> AutomationContext: ...
 
 
 def run_function(
@@ -134,6 +175,7 @@ def run_function(
         if automation_context.run_status not in [
             AutomationStatus.FAILED,
             AutomationStatus.SUCCEEDED,
+            AutomationStatus.EXCEPTION,
         ]:
             automation_context.mark_run_success(
                 "WARNING: Automate assumed a success status,"
@@ -142,11 +184,11 @@ def run_function(
     except Exception:
         trace = traceback.format_exc()
         print(trace)
-        automation_context.mark_run_failed(
+        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
+    return automation_context

src/speckle_automate/schema.py

@@ -1,6 +1,7 @@
 """"""
+
 from enum import Enum
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Literal, Optional
 
 from pydantic import BaseModel, ConfigDict, Field
 from stringcase import camelcase
@@ -12,22 +13,43 @@ class AutomateBase(BaseModel):
     model_config = ConfigDict(alias_generator=camelcase, 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
-    model_id: str
-    branch_name: str
-    version_id: str
     speckle_server_url: str
-
     automation_id: str
-    automation_revision_id: str
     automation_run_id: str
+    function_run_id: str
 
-    function_id: str
-    function_name: str
-    function_logo: Optional[str]
+    triggers: List[VersionCreationTrigger]
+
+    model_config = ConfigDict(
+        alias_generator=camelcase, 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=camelcase, populate_by_name=True, protected_namespaces=()
@@ -41,11 +63,13 @@ class AutomationStatus(str, Enum):
     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"

src/specklepy/__init__.py

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

src/specklepy/api/client.py

@@ -1,24 +1,26 @@
-from deprecated import deprecated
-from gql.transport.exceptions import TransportServerError
-from gql.transport.requests import RequestsHTTPTransport
-from gql.transport.websockets import WebsocketsTransport
+import contextlib
 
-from specklepy.api.credentials import Account, get_account_from_token
+from deprecated import deprecated
+
+from specklepy.api.credentials import Account
 from specklepy.api.resources import (
-    user,
-    active_user,
+    ActiveUserResource,
+    ModelResource,
+    OtherUserResource,
+    ProjectInviteResource,
+    ProjectResource,
+    ServerResource,
+    SubscriptionResource,
+    VersionResource,
     branch,
     commit,
     object,
-    other_user,
-    server,
     stream,
     subscriptions,
+    user,
 )
-from specklepy.logging import metrics
-from specklepy.logging.exceptions import SpeckleException, SpeckleWarning
-
 from specklepy.core.api.client import SpeckleClient as CoreSpeckleClient
+from specklepy.logging import metrics
 
 
 class SpeckleClient(CoreSpeckleClient):
@@ -26,7 +28,7 @@ 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 `speckle.xyz`.
+    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)
@@ -37,10 +39,11 @@ class SpeckleClient(CoreSpeckleClient):
     from specklepy.api.credentials import get_default_account
 
     # initialise the client
-    client = SpeckleClient(host="speckle.xyz") # or whatever your host is
+    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)
+    # authenticate the client with an account
+    # (account has been added in Speckle Manager)
     account = get_default_account()
     client.authenticate_with_account(account)
 
@@ -52,43 +55,81 @@ class SpeckleClient(CoreSpeckleClient):
     ```
     """
 
-    DEFAULT_HOST = "speckle.xyz"
+    DEFAULT_HOST = "app.speckle.systems"
     USE_SSL = True
 
-    def __init__(self, host: str = DEFAULT_HOST, use_ssl: bool = USE_SSL) -> None:
+    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 = server.Resource(
+        self.server = ServerResource(
             account=self.account, basepath=self.url, client=self.httpclient
         )
+
         server_version = None
-        try:
+
+        with contextlib.suppress(Exception):
             server_version = self.server.version()
-        except Exception:
-            pass
+
+        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.subscription = SubscriptionResource(
+            account=self.account,
+            basepath=self.ws_url,
+            client=self.wsclient,
+            # todo: why doesn't this take a server version
+        )
+        # Deprecated Resources
         self.user = user.Resource(
             account=self.account,
             basepath=self.url,
             client=self.httpclient,
             server_version=server_version,
         )
-        self.other_user = other_user.Resource(
-            account=self.account,
-            basepath=self.url,
-            client=self.httpclient,
-            server_version=server_version,
-        )
-        self.active_user = active_user.Resource(
-            account=self.account,
-            basepath=self.url,
-            client=self.httpclient,
-            server_version=server_version,
-        )
         self.stream = stream.Resource(
             account=self.account,
             basepath=self.url,

src/specklepy/api/credentials.py

@@ -1,23 +1,17 @@
-import os
 from typing import List, Optional
 
-from pydantic import BaseModel, Field  # pylint: disable=no-name-in-module
-
-from specklepy.api.models import ServerInfo
-from specklepy.core.helpers import speckle_path_provider
-from specklepy.logging import metrics
-from specklepy.logging.exceptions import SpeckleException
-from specklepy.transports.sqlite import SQLiteTransport
-
 # 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 (
+from specklepy.core.api.credentials import (  # noqa: F401
     Account,
+    StreamWrapper,  # noqa: F401
     UserInfo,
-    StreamWrapper,  # deprecated
-    get_local_accounts as core_get_local_accounts,
+)
+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]:

src/specklepy/api/host_applications.py

@@ -1,18 +1,74 @@
-from dataclasses import dataclass
-from enum import Enum
-from unicodedata import name
+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,
+)
 
-# 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.host_applications import (HostApplication, HostAppVersion,
-                                                  get_host_app_from_string, 
-                                                  _app_name_host_app_mapping,
-                                                  RHINO,GRASSHOPPER,REVIT,DYNAMO,UNITY,GSA,
-                                                  CIVIL,AUTOCAD,MICROSTATION,OPENROADS,
-                                                  OPENRAIL,OPENBUILDINGS,ETABS,SAP2000,CSIBRIDGE,
-                                                  SAFE,TEKLASTRUCTURES,DXF,EXCEL,UNREAL,POWERBI,
-                                                  BLENDER,QGIS,ARCGIS,SKETCHUP,ARCHICAD,TOPSOLID,
-                                                  PYTHON,NET,OTHER)
-
-if __name__ == "__main__":
-    print(HostAppVersion.v)
+# 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.py

@@ -1,12 +0,0 @@
-from datetime import datetime
-from typing import List, Optional
-
-from pydantic import BaseModel, Field
-
-# 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 (Collaborator, Commit,
-                                       Commits, Object, Branch, Branches,
-                                       Stream, Streams, User, LimitedUser,
-                                       PendingStreamCollaborator, Activity,
-                                       ActivityCollection, ServerInfo)

src/specklepy/api/models/__init__.py

@@ -0,0 +1,35 @@
+# 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 (
+    Activity,
+    ActivityCollection,
+    Branch,
+    Branches,
+    Collaborator,
+    Commit,
+    Commits,
+    LimitedUser,
+    Object,
+    PendingStreamCollaborator,
+    ServerInfo,
+    Stream,
+    Streams,
+    User,
+)
+
+__all__ = [
+    "Activity",
+    "ActivityCollection",
+    "Branch",
+    "Branches",
+    "Collaborator",
+    "Commit",
+    "Commits",
+    "LimitedUser",
+    "Object",
+    "PendingStreamCollaborator",
+    "ServerInfo",
+    "Stream",
+    "Streams",
+    "User",
+]

src/specklepy/api/operations.py

@@ -1,16 +1,12 @@
 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.logging.exceptions import SpeckleException
 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
-
-from specklepy.core.api.operations import (send as core_send,
-                                           receive as _untracked_receive,
-                                           serialize as core_serialize,
-                                           deserialize as core_deserialize)
 
 
 def send(
@@ -57,7 +53,9 @@ def receive(
     return _untracked_receive(obj_id, remote_transport, local_transport)
 
 
-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
@@ -71,9 +69,12 @@ def serialize(base: Base, write_transports: List[AbstractTransport] = []) -> str
     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:

src/specklepy/api/resource.py

@@ -1,21 +1,8 @@
-from threading import Lock
-from typing import Any, Dict, List, Optional, Tuple, Type, Union
+from typing import Any, Optional, Tuple
 
 from gql.client import Client
-from gql.transport.exceptions import TransportQueryError
-from graphql import DocumentNode
 
 from specklepy.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
-
-# 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.resource import ResourceBase as CoreResourceBase
 
 
@@ -29,10 +16,9 @@ class ResourceBase(CoreResourceBase):
         server_version: Optional[Tuple[Any, ...]] = None,
     ) -> None:
         super().__init__(
-            account = account,
-            basepath = basepath,
-            client = client,
-            name = name,
-            server_version = server_version
+            account=account,
+            basepath=basepath,
+            client=client,
+            name=name,
+            server_version=server_version,
         )
-    

src/specklepy/api/resources/__init__.py

@@ -1,9 +1,41 @@
-import pkgutil
-import sys
-from importlib import import_module
+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.deprecated import (
+    active_user,
+    branch,
+    commit,
+    object,
+    other_user,
+    server,
+    stream,
+    subscriptions,
+    user,
+)
 
-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)
+__all__ = [
+    "ActiveUserResource",
+    "ModelResource",
+    "OtherUserResource",
+    "ProjectInviteResource",
+    "ProjectResource",
+    "ServerResource",
+    "SubscriptionResource",
+    "VersionResource",
+    "active_user",
+    "branch",
+    "commit",
+    "object",
+    "other_user",
+    "server",
+    "stream",
+    "subscriptions",
+    "user",
+]

src/specklepy/api/resources/active_user.py

@@ -1,120 +0,0 @@
-from datetime import datetime, timezone
-from typing import List, Optional
-
-from gql import gql
-
-from specklepy.api.models import ActivityCollection, PendingStreamCollaborator, User
-from specklepy.api.resource import ResourceBase
-from specklepy.logging import metrics
-from specklepy.logging.exceptions import SpeckleException
-
-from specklepy.core.api.resources.active_user import Resource as CoreResource
-
-
-class Resource(CoreResource):
-    """API Access class for users"""
-
-    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) -> 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
-        """
-        metrics.track(metrics.SDK, custom_props={"name": "User Active Get"})
-        return super().get()
-
-    def update(
-        self,
-        name: Optional[str] = None,
-        company: Optional[str] = None,
-        bio: Optional[str] = None,
-        avatar: Optional[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    @deprecated(version=DEPRECATION_VERSION, reason=DEPRECATION_TEXT):
-            bool -- True if your profile was updated successfully
-        """
-        metrics.track(metrics.SDK, self.account, {"name": "User Active Update"})
-        return super().update(name, company, bio, avatar)
-
-    def activity(
-        self,
-        limit: int = 20,
-        action_type: Optional[str] = None,
-        before: Optional[datetime] = None,
-        after: Optional[datetime] = None,
-        cursor: Optional[datetime] = None,
-    ):
-        """
-        Get the activity from a given stream in an Activity collection.
-        Step into the activity `items` for the list of activity.
-        If no id argument is provided, will return the current authenticated user's
-        activity (as extracted from the authorization header).
-
-        Note: all timestamps arguments should be `datetime` of any tz as they will be
-        converted to UTC ISO format strings
-
-        user_id {str} -- the id of the user to get the activity from
-        action_type {str} -- filter results to a single action type
-            (eg: `commit_create` or `commit_receive`)
-        limit {int} -- max number of Activity items to return
-        before {datetime} -- latest cutoff for activity
-            (ie: return all activity _before_ this time)
-        after {datetime} -- oldest cutoff for activity
-            (ie: return all activity _after_ this time)
-        cursor {datetime} -- timestamp cursor for pagination
-        """
-        metrics.track(metrics.SDK, self.account, {"name": "User Active Activity"})
-        return super().activity(limit, action_type, before, after, cursor)
-
-    def get_all_pending_invites(self) -> List[PendingStreamCollaborator]:
-        """Get all of the active user's pending stream invites
-
-        Requires Speckle Server version >= 2.6.4
-
-        Returns:
-            List[PendingStreamCollaborator]
-            -- a list of pending invites for the current user
-        """
-        metrics.track(metrics.SDK, self.account, {"name": "User Active Invites All Get"})
-        return super().get_all_pending_invites()
-
-    def get_pending_invite(
-        self, stream_id: str, token: Optional[str] = None
-    ) -> Optional[PendingStreamCollaborator]:
-        """Get a particular pending invite for the active user on a given stream.
-        If no invite_id is provided, any valid invite will be returned.
-
-        Requires Speckle Server version >= 2.6.4
-
-        Arguments:
-            stream_id {str} -- the id of the stream to look for invites on
-            token {str} -- the token of the invite to look for (optional)
-
-        Returns:
-            PendingStreamCollaborator
-            -- the invite for the given stream (or None if it isn't found)
-        """
-        metrics.track(metrics.SDK, self.account, {"name": "User Active Invite Get"})
-        return super().get_pending_invite(stream_id, token)

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

@@ -0,0 +1,145 @@
+from datetime import datetime
+from typing import List, Optional, overload
+
+from deprecated import deprecated
+
+from specklepy.core.api.inputs.user_inputs import UserProjectsFilter, UserUpdateInput
+from specklepy.core.api.models import (
+    PendingStreamCollaborator,
+    Project,
+    ResourceCollection,
+    User,
+)
+from specklepy.core.api.models.deprecated import (
+    FE1_DEPRECATION_REASON,
+    FE1_DEPRECATION_VERSION,
+)
+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()
+
+    @deprecated("Use UserUpdateInput overload", version=FE1_DEPRECATION_VERSION)
+    @overload
+    def update(
+        self,
+        name: Optional[str] = None,
+        company: Optional[str] = None,
+        bio: Optional[str] = None,
+        avatar: Optional[str] = None,
+    ) -> User: ...
+
+    @overload
+    def update(self, *, input: UserUpdateInput) -> User: ...
+
+    def update(
+        self,
+        name: Optional[str] = None,
+        company: Optional[str] = None,
+        bio: Optional[str] = None,
+        avatar: Optional[str] = None,
+        *,
+        input: Optional[UserUpdateInput] = None,
+    ) -> User:
+        metrics.track(metrics.SDK, self.account, {"name": "Active User Update"})
+        if isinstance(input, UserUpdateInput):
+            return super()._update(input=input)
+        else:
+            return super()._update(
+                input=UserUpdateInput(
+                    name=name,
+                    company=company,
+                    bio=bio,
+                    avatar=avatar,
+                )
+            )
+
+    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_project_invites(self) -> List[PendingStreamCollaborator]:
+        metrics.track(
+            metrics.SDK, self.account, {"name": "Active User Get Project Invites"}
+        )
+        return super().get_project_invites()
+
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
+    def activity(
+        self,
+        limit: int = 20,
+        action_type: Optional[str] = None,
+        before: Optional[datetime] = None,
+        after: Optional[datetime] = None,
+        cursor: Optional[datetime] = None,
+    ):
+        """
+        Fetches collection the current authenticated user's activity
+        as filtered by given parameters
+
+        Note: all timestamps arguments should be `datetime` of any tz as they will be
+        converted to UTC ISO format strings
+
+        Args:
+            limit (int): The maximum number of activity items to return.
+            action_type (Optional[str]): Filter results to a single action type.
+            before (Optional[datetime]): Latest cutoff for activity to include.
+            after (Optional[datetime]): Oldest cutoff for an activity to include.
+            cursor (Optional[datetime]): Timestamp cursor for pagination.
+
+        Returns:
+            Activity collection, filtered according to the provided parameters.
+        """
+        metrics.track(metrics.SDK, self.account, {"name": "User Active Activity"})
+        return super().activity(limit, action_type, before, after, cursor)
+
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
+    def get_all_pending_invites(self) -> List[PendingStreamCollaborator]:
+        """Fetches all of the current user's pending stream invitations.
+
+        Returns:
+            List[PendingStreamCollaborator]: A list of pending stream invitations.
+        """
+        metrics.track(
+            metrics.SDK, self.account, {"name": "User Active Invites All Get"}
+        )
+        return super().get_all_pending_invites()
+
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
+    def get_pending_invite(
+        self, stream_id: str, token: Optional[str] = None
+    ) -> Optional[PendingStreamCollaborator]:
+        """Fetches a specific pending invite for the current user on a given stream.
+
+        Args:
+            stream_id (str): The ID of the stream to look for invites on.
+            token (Optional[str]): The token of the invite to look for (optional).
+
+        Returns:
+            Optional[PendingStreamCollaborator]: The invite for the given stream,
+            or None if not found.
+        """
+        metrics.track(metrics.SDK, self.account, {"name": "User Active Invite Get"})
+        return super().get_pending_invite(stream_id, token)

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,108 @@
+from datetime import datetime
+from typing import List, Optional, Union
+
+from deprecated import deprecated
+
+from specklepy.core.api.models import (
+    ActivityCollection,
+    LimitedUser,
+    UserSearchResultCollection,
+)
+from specklepy.core.api.models.deprecated import (
+    FE1_DEPRECATION_REASON,
+    FE1_DEPRECATION_VERSION,
+)
+from specklepy.core.api.resources import OtherUserResource as CoreResource
+from specklepy.logging import metrics
+from specklepy.logging.exceptions import SpeckleException
+
+
+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
+        )
+
+    @deprecated(reason="Use user_search instead", version=FE1_DEPRECATION_VERSION)
+    def search(
+        self, search_query: str, limit: int = 25
+    ) -> Union[List[LimitedUser], SpeckleException]:
+        """
+        Searches for users by name or email.
+        The search requires a minimum query length of 3 characters.
+
+        Args:
+            search_query (str): The search string.
+            limit (int): Maximum number of search results to return.
+
+        Returns:
+            Union[List[LimitedUser], SpeckleException]:
+                A list of users matching the search
+                query or an exception if the query is too short.
+        """
+        if len(search_query) < 3:
+            return SpeckleException(
+                message="User search query must be at least 3 characters."
+            )
+
+        metrics.track(metrics.SDK, self.account, {"name": "Other User Search"})
+        return super().search(search_query, limit)
+
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
+    def activity(
+        self,
+        user_id: str,
+        limit: int = 20,
+        action_type: Optional[str] = None,
+        before: Optional[datetime] = None,
+        after: Optional[datetime] = None,
+        cursor: Optional[datetime] = None,
+    ) -> ActivityCollection:
+        """
+        Retrieves a collection of activities for a specified user,
+        with optional filters for activity type, time frame, and pagination.
+
+        Args:
+            user_id (str): The ID of the user whose activities are being requested.
+            limit (int): The maximum number of activity items to return.
+            action_type (Optional[str]): A specific type of activity to filter.
+            before (Optional[datetime]): Latest timestamp to include activities before.
+            after (Optional[datetime]): Earliest timestamp to include activities after.
+            cursor (Optional[datetime]): Timestamp for pagination cursor.
+
+        Returns:
+            ActivityCollection: A collection of user activities filtered
+            according to specified criteria.
+        """
+        metrics.track(metrics.SDK, self.account, {"name": "Other User Activity"})
+        return super().activity(user_id, limit, action_type, before, after, cursor)

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,63 @@
+from typing import Optional
+
+from specklepy.core.api.inputs.project_inputs import (
+    ProjectCreateInput,
+    ProjectModelsFilter,
+    ProjectUpdateInput,
+    ProjectUpdateRoleInput,
+)
+from specklepy.core.api.models import Project, ProjectWithModels, ProjectWithTeam
+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_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 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

@@ -1,17 +1,11 @@
-import re
 from typing import Any, Dict, List, Tuple
 
-from gql import gql
-
 from specklepy.api.models import ServerInfo
-from specklepy.api.resource import ResourceBase
+from specklepy.core.api.resources import ServerResource as CoreResource
 from specklepy.logging import metrics
-from specklepy.logging.exceptions import GraphQLException
-
-from specklepy.core.api.resources.server import Resource as CoreResource
 
 
-class Resource(CoreResource):
+class ServerResource(CoreResource):
     """API Access class for the server"""
 
     def __init__(self, account, basepath, client) -> None:
@@ -37,7 +31,8 @@ class Resource(CoreResource):
             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
+        # not tracking as it will be called along with other
+        # mutations / queries as a check
         return super().version()
 
     def apps(self) -> Dict:
@@ -73,4 +68,4 @@ class Resource(CoreResource):
             bool -- True if the token was successfully deleted
         """
         metrics.track(metrics.SDK, self.account, {"name": "Server Revoke Token"})
-        return super().revoke_token(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) -> str:
+        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/deprecated/active_user.py

@@ -0,0 +1,9 @@
+from deprecated import deprecated
+
+from specklepy.api.resources import ActiveUserResource
+from specklepy.core.api.models.deprecated import FE1_DEPRECATION_VERSION
+
+
+@deprecated(reason="Renamed to ActiveUserResource", version=FE1_DEPRECATION_VERSION)
+class Resource(ActiveUserResource):
+    """Renamed to ActiveUserResource"""

src/specklepy/api/resources/deprecated/branch.py

@@ -1,12 +1,15 @@
-from typing import Optional
+from typing import Optional, Union
 
-from gql import gql
+from deprecated import deprecated
 
 from specklepy.api.models import Branch
-from specklepy.api.resource import ResourceBase
+from specklepy.core.api.models.deprecated import (
+    FE1_DEPRECATION_REASON,
+    FE1_DEPRECATION_VERSION,
+)
+from specklepy.core.api.resources.deprecated.branch import Resource as CoreResource
 from specklepy.logging import metrics
-
-from specklepy.core.api.resources.branch import Resource as CoreResource
+from specklepy.logging.exceptions import SpeckleException
 
 
 class Resource(CoreResource):
@@ -20,6 +23,7 @@ class Resource(CoreResource):
         )
         self.schema = Branch
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def create(
         self, stream_id: str, name: str, description: str = "No description provided"
     ) -> str:
@@ -35,7 +39,10 @@ class Resource(CoreResource):
         metrics.track(metrics.SDK, self.account, {"name": "Branch Create"})
         return super().create(stream_id, name, description)
 
-    def get(self, stream_id: str, name: str, commits_limit: int = 10):
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
+    def get(
+        self, stream_id: str, name: str, commits_limit: int = 10
+    ) -> Union[Branch, None, SpeckleException]:
         """Get a branch by name from a stream
 
         Arguments:
@@ -49,6 +56,7 @@ class Resource(CoreResource):
         metrics.track(metrics.SDK, self.account, {"name": "Branch Get"})
         return super().get(stream_id, name, commits_limit)
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def list(self, stream_id: str, branches_limit: int = 10, commits_limit: int = 10):
         """Get a list of branches from a given stream
 
@@ -63,6 +71,7 @@ class Resource(CoreResource):
         metrics.track(metrics.SDK, self.account, {"name": "Branch List"})
         return super().list(stream_id, branches_limit, commits_limit)
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def update(
         self,
         stream_id: str,
@@ -84,6 +93,7 @@ class Resource(CoreResource):
         metrics.track(metrics.SDK, self.account, {"name": "Branch Update"})
         return super().update(stream_id, branch_id, name, description)
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def delete(self, stream_id: str, branch_id: str):
         """Delete a branch
 

src/specklepy/api/resources/deprecated/commit.py

@@ -1,12 +1,14 @@
 from typing import List, Optional, Union
 
-from gql import gql
+from deprecated import deprecated
 
 from specklepy.api.models import Commit
-from specklepy.api.resource import ResourceBase
+from specklepy.core.api.models.deprecated import (
+    FE1_DEPRECATION_REASON,
+    FE1_DEPRECATION_VERSION,
+)
+from specklepy.core.api.resources.deprecated.commit import Resource as CoreResource
 from specklepy.logging import metrics
-
-from specklepy.core.api.resources.commit import Resource as CoreResource
 from specklepy.logging.exceptions import SpeckleException
 
 
@@ -21,6 +23,7 @@ class Resource(CoreResource):
         )
         self.schema = Commit
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def get(self, stream_id: str, commit_id: str) -> Commit:
         """
         Gets a commit given a stream and the commit id
@@ -35,6 +38,7 @@ class Resource(CoreResource):
         metrics.track(metrics.SDK, self.account, {"name": "Commit Get"})
         return super().get(stream_id, commit_id)
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def list(self, stream_id: str, limit: int = 10) -> List[Commit]:
         """
         Get a list of commits on a given stream
@@ -49,6 +53,7 @@ class Resource(CoreResource):
         metrics.track(metrics.SDK, self.account, {"name": "Commit List"})
         return super().list(stream_id, limit)
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def create(
         self,
         stream_id: str,
@@ -81,6 +86,7 @@ class Resource(CoreResource):
             stream_id, object_id, branch_name, message, source_application, parents
         )
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def update(self, stream_id: str, commit_id: str, message: str) -> bool:
         """
         Update a commit
@@ -97,6 +103,7 @@ class Resource(CoreResource):
         metrics.track(metrics.SDK, self.account, {"name": "Commit Update"})
         return super().update(stream_id, commit_id, message)
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def delete(self, stream_id: str, commit_id: str) -> bool:
         """
         Delete a commit
@@ -112,6 +119,7 @@ class Resource(CoreResource):
         metrics.track(metrics.SDK, self.account, {"name": "Commit Delete"})
         return super().delete(stream_id, commit_id)
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def received(
         self,
         stream_id: str,

src/specklepy/api/resources/deprecated/object.py

@@ -1,13 +1,14 @@
 from typing import Dict, List
 
-from gql import gql
-
-from specklepy.api.resource import ResourceBase
-from specklepy.objects.base import Base
+from deprecated import deprecated
 
+from specklepy.core.api.models.deprecated import (
+    FE1_DEPRECATION_REASON,
+    FE1_DEPRECATION_VERSION,
+)
+from specklepy.core.api.resources.deprecated.object import Resource as CoreResource
 from specklepy.logging import metrics
-
-from specklepy.core.api.resources.object import Resource as CoreResource
+from specklepy.objects.base import Base
 
 
 class Resource(CoreResource):
@@ -21,6 +22,7 @@ class Resource(CoreResource):
         )
         self.schema = Base
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def get(self, stream_id: str, object_id: str) -> Base:
         """
         Get a stream object
@@ -35,6 +37,7 @@ class Resource(CoreResource):
         metrics.track(metrics.SDK, self.account, {"name": "Object Get"})
         return super().get(stream_id, object_id)
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def create(self, stream_id: str, objects: List[Dict]) -> str:
         """
         Not advised - generally, you want to use `operations.send()`.
@@ -58,4 +61,3 @@ class Resource(CoreResource):
         """
         metrics.track(metrics.SDK, self.account, {"name": "Object Create"})
         return super().create(stream_id, objects)
-    

src/specklepy/api/resources/deprecated/other_user.py

@@ -0,0 +1,11 @@
+from deprecated import deprecated
+
+from specklepy.api.resources import OtherUserResource
+from specklepy.core.api.models.deprecated import FE1_DEPRECATION_VERSION
+
+
+@deprecated(reason="Renamed to OtherUserResource", version=FE1_DEPRECATION_VERSION)
+class Resource(OtherUserResource):
+    """
+    Renamed to OtherUserResource
+    """

src/specklepy/api/resources/deprecated/server.py

@@ -0,0 +1,9 @@
+from deprecated import deprecated
+
+from specklepy.api.resources import ServerResource
+from specklepy.core.api.models.deprecated import FE1_DEPRECATION_VERSION
+
+
+@deprecated(reason="Renamed to ServerResource", version=FE1_DEPRECATION_VERSION)
+class Resource(ServerResource):
+    """Renamed to ServerResource"""

src/specklepy/api/resources/deprecated/stream.py

@@ -1,15 +1,15 @@
-from datetime import datetime, timezone
+from datetime import datetime
 from typing import List, Optional
 
 from deprecated import deprecated
-from gql import gql
 
-from specklepy.api.models import ActivityCollection, PendingStreamCollaborator, Stream
-from specklepy.api.resource import ResourceBase
+from specklepy.api.models import PendingStreamCollaborator, Stream
+from specklepy.core.api.models.deprecated import (
+    FE1_DEPRECATION_REASON,
+    FE1_DEPRECATION_VERSION,
+)
+from specklepy.core.api.resources.deprecated.stream import Resource as CoreResource
 from specklepy.logging import metrics
-from specklepy.logging.exceptions import SpeckleException, UnsupportedException
-
-from specklepy.core.api.resources.stream import Resource as CoreResource
 
 
 class Resource(CoreResource):
@@ -25,6 +25,7 @@ class Resource(CoreResource):
 
         self.schema = Stream
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def get(self, id: str, branch_limit: int = 10, commit_limit: int = 10) -> Stream:
         """Get the specified stream from the server
 
@@ -39,6 +40,7 @@ class Resource(CoreResource):
         metrics.track(metrics.SDK, self.account, {"name": "Stream Get"})
         return super().get(id, branch_limit, commit_limit)
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def list(self, stream_limit: int = 10) -> List[Stream]:
         """Get a list of the user's streams
 
@@ -51,6 +53,7 @@ class Resource(CoreResource):
         metrics.track(metrics.SDK, self.account, {"name": "Stream List"})
         return super().list(stream_limit)
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def create(
         self,
         name: str = "Anonymous Python Stream",
@@ -71,6 +74,7 @@ class Resource(CoreResource):
         metrics.track(metrics.SDK, self.account, {"name": "Stream Create"})
         return super().create(name, description, is_public)
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def update(
         self,
         id: str,
@@ -93,6 +97,7 @@ class Resource(CoreResource):
         metrics.track(metrics.SDK, self.account, {"name": "Stream Update"})
         return super().update(id, name, description, is_public)
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def delete(self, id: str) -> bool:
         """Delete a stream given its id
 
@@ -105,6 +110,7 @@ class Resource(CoreResource):
         metrics.track(metrics.SDK, self.account, {"name": "Stream Delete"})
         return super().delete(id)
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def search(
         self,
         search_query: str,
@@ -126,6 +132,7 @@ class Resource(CoreResource):
         metrics.track(metrics.SDK, self.account, {"name": "Stream Search"})
         return super().search(search_query, limit, branch_limit, commit_limit)
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def favorite(self, stream_id: str, favorited: bool = True):
         """Favorite or unfavorite the given stream.
 
@@ -140,6 +147,7 @@ class Resource(CoreResource):
         metrics.track(metrics.SDK, self.account, {"name": "Stream Favorite"})
         return super().favorite(stream_id, favorited)
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def get_all_pending_invites(
         self, stream_id: str
     ) -> List[PendingStreamCollaborator]:
@@ -158,6 +166,7 @@ class Resource(CoreResource):
         metrics.track(metrics.SDK, self.account, {"name": "Stream Invite Get"})
         return super().get_all_pending_invites(stream_id)
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def invite(
         self,
         stream_id: str,
@@ -185,6 +194,7 @@ class Resource(CoreResource):
         metrics.track(metrics.SDK, self.account, {"name": "Stream Invite Create"})
         return super().invite(stream_id, email, user_id, role, message)
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def invite_batch(
         self,
         stream_id: str,
@@ -211,6 +221,7 @@ class Resource(CoreResource):
         metrics.track(metrics.SDK, self.account, {"name": "Stream Invite Batch Create"})
         return super().invite_batch(stream_id, emails, user_ids, message)
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def invite_cancel(self, stream_id: str, invite_id: str) -> bool:
         """Cancel an existing stream invite
 
@@ -226,6 +237,7 @@ class Resource(CoreResource):
         metrics.track(metrics.SDK, self.account, {"name": "Stream Invite Cancel"})
         return super().invite_cancel(stream_id, invite_id)
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def invite_use(self, stream_id: str, token: str, accept: bool = True) -> bool:
         """Accept or decline a stream invite
 
@@ -243,6 +255,7 @@ class Resource(CoreResource):
         metrics.track(metrics.SDK, self.account, {"name": "Invite Use"})
         return super().invite_use(stream_id, token, accept)
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def update_permission(self, stream_id: str, user_id: str, role: str):
         """Updates permissions for a user on a given stream
 
@@ -256,9 +269,14 @@ class Resource(CoreResource):
         Returns:
             bool -- True if the operation was successful
         """
-        metrics.track(metrics.SDK, self.account, {"name": "Stream Permission Update", "role": role})
+        metrics.track(
+            metrics.SDK,
+            self.account,
+            {"name": "Stream Permission Update", "role": role},
+        )
         return super().update_permission(stream_id, user_id, role)
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def revoke_permission(self, stream_id: str, user_id: str):
         """Revoke permissions from a user on a given stream
 
@@ -272,6 +290,7 @@ class Resource(CoreResource):
         metrics.track(metrics.SDK, self.account, {"name": "Stream Permission Revoke"})
         return super().revoke_permission(stream_id, user_id)
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def activity(
         self,
         stream_id: str,
@@ -301,4 +320,3 @@ class Resource(CoreResource):
         """
         metrics.track(metrics.SDK, self.account, {"name": "Stream Activity"})
         return super().activity(stream_id, action_type, limit, before, after, cursor)
-    

src/specklepy/api/resources/deprecated/subscriptions.py

@@ -1,27 +1,17 @@
-from functools import wraps
 from typing import Callable, Dict, List, Optional, Union
 
-from gql import gql
+from deprecated import deprecated
 from graphql import DocumentNode
 
-from specklepy.api.resource import ResourceBase
-from specklepy.api.resources.stream import Stream
-from specklepy.logging.exceptions import SpeckleException
-
+from specklepy.core.api.models.deprecated import (
+    FE1_DEPRECATION_REASON,
+    FE1_DEPRECATION_VERSION,
+)
+from specklepy.core.api.resources.current.subscription_resource import check_wsclient
+from specklepy.core.api.resources.deprecated.subscriptions import (
+    Resource as CoreResource,
+)
 from specklepy.logging import metrics
-from specklepy.core.api.resources.subscriptions import Resource as CoreResource
-
-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(CoreResource):
@@ -34,6 +24,7 @@ class Resource(CoreResource):
             client=client,
         )
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     @check_wsclient
     async def stream_added(self, callback: Optional[Callable] = None):
         """Subscribes to new stream added event for your profile.
@@ -49,6 +40,7 @@ class Resource(CoreResource):
         metrics.track(metrics.SDK, self.account, {"name": "Subscription Stream Added"})
         return super().stream_added(callback)
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     @check_wsclient
     async def stream_updated(self, id: str, callback: Optional[Callable] = None):
         """
@@ -64,9 +56,12 @@ class Resource(CoreResource):
         Returns:
             Stream -- the update stream
         """
-        metrics.track(metrics.SDK, self.account, {"name": "Subscription Stream Updated"})
+        metrics.track(
+            metrics.SDK, self.account, {"name": "Subscription Stream Updated"}
+        )
         return super().stream_updated(id, callback)
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     @check_wsclient
     async def stream_removed(self, callback: Optional[Callable] = None):
         """Subscribes to stream removed event for your profile.
@@ -83,9 +78,12 @@ class Resource(CoreResource):
         Returns:
             dict -- dict containing 'id' of stream removed and optionally 'revokedBy'
         """
-        metrics.track(metrics.SDK, self.account, {"name": "Subscription Stream Removed"})
+        metrics.track(
+            metrics.SDK, self.account, {"name": "Subscription Stream Removed"}
+        )
         return super().stream_removed(callback)
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     @check_wsclient
     async def subscribe(
         self,

src/specklepy/api/resources/deprecated/user.py

@@ -1,16 +1,12 @@
-from datetime import datetime, timezone
+from datetime import datetime
 from typing import List, Optional, Union
 
 from deprecated import deprecated
-from gql import gql
-
-from specklepy.api.models import ActivityCollection, PendingStreamCollaborator, User
-from specklepy.api.resource import ResourceBase
-
-from specklepy.logging.exceptions import SpeckleException
 
+from specklepy.api.models import PendingStreamCollaborator, User
+from specklepy.core.api.resources.deprecated.user import Resource as CoreResource
 from specklepy.logging import metrics
-from specklepy.core.api.resources.user import Resource as CoreResource
+from specklepy.logging.exceptions import SpeckleException
 
 DEPRECATION_VERSION = "2.9.0"
 DEPRECATION_TEXT = (
@@ -46,7 +42,7 @@ class Resource(CoreResource):
         """
         metrics.track(metrics.SDK, self.account, {"name": "User Get_deprecated"})
         return super().get(id)
-        
+
     @deprecated(version=DEPRECATION_VERSION, reason=DEPRECATION_TEXT)
     def search(
         self, search_query: str, limit: int = 25
@@ -83,7 +79,7 @@ class Resource(CoreResource):
         Returns:
             bool -- True if your profile was updated successfully
         """
-        #metrics.track(metrics.USER, self.account, {"name": "update"})
+        # metrics.track(metrics.USER, self.account, {"name": "update"})
         metrics.track(metrics.SDK, self.account, {"name": "User Update_deprecated"})
         return super().update(name, company, bio, avatar)
 
@@ -118,7 +114,6 @@ class Resource(CoreResource):
         """
         metrics.track(metrics.SDK, self.account, {"name": "User Activity_deprecated"})
         return super().activity(user_id, limit, action_type, before, after, cursor)
-        
 
     @deprecated(version=DEPRECATION_VERSION, reason=DEPRECATION_TEXT)
     def get_all_pending_invites(self) -> List[PendingStreamCollaborator]:
@@ -130,10 +125,11 @@ class Resource(CoreResource):
             List[PendingStreamCollaborator]
                 -- a list of pending invites for the current user
         """
-        #metrics.track(metrics.INVITE, self.account, {"name": "get"})
-        metrics.track(metrics.SDK, self.account, {"name": "User GetAllInvites_deprecated"})
+        # metrics.track(metrics.INVITE, self.account, {"name": "get"})
+        metrics.track(
+            metrics.SDK, self.account, {"name": "User GetAllInvites_deprecated"}
+        )
         return super().get_all_pending_invites()
-        
 
     @deprecated(version=DEPRECATION_VERSION, reason=DEPRECATION_TEXT)
     def get_pending_invite(
@@ -152,7 +148,6 @@ class Resource(CoreResource):
             PendingStreamCollaborator
                 -- the invite for the given stream (or None if it isn't found)
         """
-        #metrics.track(metrics.INVITE, self.account, {"name": "get"})
+        # metrics.track(metrics.INVITE, self.account, {"name": "get"})
         metrics.track(metrics.SDK, self.account, {"name": "User GetInvite_deprecated"})
         return super().get_pending_invite(stream_id, token)
-        

src/specklepy/api/resources/other_user.py

@@ -1,87 +0,0 @@
-from datetime import datetime, timezone
-from typing import List, Optional, Union
-
-from gql import gql
-
-from specklepy.api.models import ActivityCollection, LimitedUser
-from specklepy.api.resource import ResourceBase
-from specklepy.logging import metrics
-from specklepy.logging.exceptions import SpeckleException
-
-from specklepy.core.api.resources.other_user import Resource as CoreResource
-
-
-class Resource(CoreResource):
-    """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,
-            server_version=server_version,
-        )
-        self.schema = LimitedUser
-
-    def get(self, id: str) -> LimitedUser:
-        """
-        Gets the profile of another user.
-
-        Arguments:
-            id {str} -- the user id
-
-        Returns:
-            LimitedUser -- the retrieved profile of another user
-        """
-        metrics.track(metrics.SDK, self.account, {"name": "Other User Get"})
-        return super().get(id)
-
-    def search(
-        self, search_query: str, limit: int = 25
-    ) -> Union[List[LimitedUser], SpeckleException]:
-        """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[LimitedUser] -- 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"
-            )
-
-        metrics.track(metrics.SDK, self.account, {"name": "Other User Search"})
-        return super().search(search_query, limit) 
-
-    def activity(
-        self,
-        user_id: str,
-        limit: int = 20,
-        action_type: Optional[str] = None,
-        before: Optional[datetime] = None,
-        after: Optional[datetime] = None,
-        cursor: Optional[datetime] = None,
-    ) -> ActivityCollection:
-        """
-        Get the activity from a given stream in an Activity collection.
-        Step into the activity `items` for the list of activity.
-
-        Note: all timestamps arguments should be `datetime` of
-        any tz as they will be converted to UTC ISO format strings
-
-        user_id {str} -- the id of the user to get the activity from
-        action_type {str} -- filter results to a single action type
-            (eg: `commit_create` or `commit_receive`)
-        limit {int} -- max number of Activity items to return
-        before {datetime} -- latest cutoff for activity
-            (ie: return all activity _before_ this time)
-        after {datetime} -- oldest cutoff for activity
-            (ie: return all activity _after_ this time)
-        cursor {datetime} -- timestamp cursor for pagination
-        """
-        metrics.track(metrics.SDK, self.account, {"name": "Other User Activity"})
-        return super().activity(user_id, limit, action_type, before, after, cursor) 
-    

src/specklepy/api/wrapper.py

@@ -1,17 +1,9 @@
-from urllib.parse import unquote, urlparse
-from warnings import warn
-
 from specklepy.api.client import SpeckleClient
-from specklepy.api.credentials import (
-    Account,
-    get_account_from_token,
-    get_local_accounts,
-)
-from specklepy.logging.exceptions import SpeckleException, SpeckleWarning
+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
 
-from specklepy.logging import metrics
-from specklepy.core.api.wrapper import StreamWrapper as CoreStreamWrapper 
 
 class StreamWrapper(CoreStreamWrapper):
     """
@@ -30,7 +22,7 @@ class StreamWrapper(CoreStreamWrapper):
     from specklepy.api.wrapper import StreamWrapper
 
     # provide any stream, branch, commit, object, or globals url
-    wrapper = StreamWrapper("https://speckle.xyz/streams/3073b96e86/commits/604bea8cc6")
+    wrapper = StreamWrapper("https://app.speckle.systems/streams/3073b96e86/commits/604bea8cc6")
 
     # get an authenticated SpeckleClient if you have a local account for the server
     client = wrapper.get_client()
@@ -51,7 +43,7 @@ class StreamWrapper(CoreStreamWrapper):
     _account: Account = None
 
     def __init__(self, url: str) -> None:
-        super().__init__(url = url)
+        super().__init__(url=url)
 
     def get_account(self, token: str = None) -> Account:
         """
@@ -90,5 +82,7 @@ class StreamWrapper(CoreStreamWrapper):
             ServerTransport -- constructed for this stream
             with a pre-authenticated client
         """
-        metrics.track(metrics.SDK, custom_props={"name": "Stream Wrapper Get Transport"})
+        metrics.track(
+            metrics.SDK, custom_props={"name": "Stream Wrapper Get Transport"}
+        )
         return super().get_transport(token)

src/specklepy/core/api/client.py

@@ -1,3 +1,4 @@
+import contextlib
 import re
 from typing import Dict
 from warnings import warn
@@ -11,15 +12,20 @@ from gql.transport.websockets import WebsocketsTransport
 from specklepy.core.api import resources
 from specklepy.core.api.credentials import Account, get_account_from_token
 from specklepy.core.api.resources import (
-    user,
-    active_user,
+    ActiveUserResource,
+    ModelResource,
+    OtherUserResource,
+    ProjectInviteResource,
+    ProjectResource,
+    ServerResource,
+    SubscriptionResource,
+    VersionResource,
     branch,
     commit,
     object,
-    other_user,
-    server,
     stream,
     subscriptions,
+    user,
 )
 from specklepy.logging import metrics
 from specklepy.logging.exceptions import SpeckleException, SpeckleWarning
@@ -30,7 +36,7 @@ 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`.
+    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)
@@ -41,10 +47,11 @@ class 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="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)
+    # authenticate the client with an account
+    # (account has been added in Speckle Manager)
     account = get_default_account()
     client.authenticate_with_account(account)
 
@@ -56,10 +63,17 @@ class SpeckleClient:
     ```
     """
 
-    DEFAULT_HOST = "speckle.xyz"
+    DEFAULT_HOST = "app.speckle.systems"
     USE_SSL = True
 
-    def __init__(self, host: str = DEFAULT_HOST, use_ssl: bool = USE_SSL) -> None:
+    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"
 
@@ -74,15 +88,24 @@ class SpeckleClient:
         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=True, retries=3)
+            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
+        # ? 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):
@@ -115,8 +138,7 @@ class SpeckleClient:
         Arguments:
             token {str} -- an api token
         """
-        self.authenticate_with_token(token)
-        self._set_up_client()
+        self.authenticate_with_account(get_account_from_token(token))
 
     def authenticate_with_token(self, token: str) -> None:
         """
@@ -127,7 +149,7 @@ class SpeckleClient:
         Arguments:
             token {str} -- an api token
         """
-        self.account = get_account_from_token(token, self.url)
+        self.account = Account.from_token(token, self.url)
         self._set_up_client()
 
     def authenticate_with_account(self, account: Account) -> None:
@@ -150,7 +172,7 @@ class SpeckleClient:
             "apollographql-client-version": metrics.HOST_APP_VERSION,
         }
         httptransport = RequestsHTTPTransport(
-            url=self.graphql, headers=headers, verify=True, retries=3
+            url=self.graphql, headers=headers, verify=self.verify_certificate, retries=3
         )
         wstransport = WebsocketsTransport(
             url=self.ws_url,
@@ -162,53 +184,80 @@ class SpeckleClient:
         self._init_resources()
 
         try:
-            user_or_error = self.active_user.get()
-            if isinstance(user_or_error, SpeckleException):
-                if isinstance(user_or_error.exception, TransportServerError):
-                    raise user_or_error.exception
-                else:
-                    raise user_or_error
-        except TransportServerError as ex:
-            if ex.code == 403:
-                warn(
-                    SpeckleWarning(
-                        "Possibly invalid token - could not authenticate Speckle Client"
-                        f" for server {self.url}"
+            _ = 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
+                else:
+                    raise ex
 
     def execute_query(self, query: str) -> Dict:
         return self.httpclient.execute(query)
 
     def _init_resources(self) -> None:
-        self.server = server.Resource(
+        self.server = ServerResource(
             account=self.account, basepath=self.url, client=self.httpclient
         )
+
         server_version = None
-        try:
+        with contextlib.suppress(Exception):
             server_version = self.server.version()
-        except Exception:
-            pass
+
+        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.subscription = SubscriptionResource(
+            account=self.account,
+            basepath=self.ws_url,
+            client=self.wsclient,
+        )
+        # Deprecated Resources
         self.user = user.Resource(
             account=self.account,
             basepath=self.url,
             client=self.httpclient,
             server_version=server_version,
         )
-        self.other_user = other_user.Resource(
-            account=self.account,
-            basepath=self.url,
-            client=self.httpclient,
-            server_version=server_version,
-        )
-        self.active_user = active_user.Resource(
-            account=self.account,
-            basepath=self.url,
-            client=self.httpclient,
-            server_version=server_version,
-        )
         self.stream = stream.Resource(
             account=self.account,
             basepath=self.url,
@@ -236,7 +285,7 @@ class SpeckleClient:
             return attr.Resource(
                 account=self.account, basepath=self.url, client=self.httpclient
             )
-        except AttributeError:
+        except AttributeError as ex:
             raise SpeckleException(
                 f"Method {name} is not supported by the SpeckleClient class"
-            )
+            ) from ex

src/specklepy/core/api/credentials.py

@@ -1,21 +1,22 @@
 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 import metrics
 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
-    id: Optional[str] = None
+    avatar: Optional[str] = None
 
 
 class Account(BaseModel):
@@ -110,7 +111,7 @@ def get_default_account(base_path: Optional[str] = None) -> Optional[Account]:
     if not default:
         default = accounts[0]
         default.isDefault = True
-    #metrics.initialise_tracker(default)
+    # metrics.initialise_tracker(default)
 
     return default
 
@@ -143,6 +144,28 @@ def get_account_from_token(token: str, server_url: str = None) -> Account:
     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.movedFrom 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(

src/specklepy/core/api/enums.py

@@ -0,0 +1,29 @@
+from enum import Enum
+
+
+class ProjectVisibility(str, Enum):
+    PRIVATE = "PRIVATE"
+    PUBLIC = "PUBLIC"
+    UNLISTEd = "UNLISTED"
+
+
+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/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 pydantic import BaseModel
+
+
+class CreateModelInput(BaseModel):
+    name: str
+    description: Optional[str] = None
+    projectId: str
+
+
+class DeleteModelInput(BaseModel):
+    id: str
+    projectId: str
+
+
+class UpdateModelInput(BaseModel):
+    id: str
+    name: Optional[str] = None
+    description: Optional[str] = None
+    projectId: str
+
+
+class ModelVersionsFilter(BaseModel):
+    priorityIds: Sequence[str]
+    priorityIdsOnly: Optional[bool] = None

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

@@ -0,0 +1,47 @@
+from typing import Optional, Sequence
+
+from pydantic import BaseModel
+
+from specklepy.core.api.enums import ProjectVisibility
+
+
+class ProjectCreateInput(BaseModel):
+    name: Optional[str]
+    description: Optional[str]
+    visibility: Optional[ProjectVisibility]
+
+
+class ProjectInviteCreateInput(BaseModel):
+    email: Optional[str]
+    role: Optional[str]
+    serverRole: Optional[str]
+    userId: Optional[str]
+
+
+class ProjectInviteUseInput(BaseModel):
+    accept: bool
+    projectId: str
+    token: str
+
+
+class ProjectModelsFilter(BaseModel):
+    contributors: Optional[Sequence[str]] = None
+    excludeIds: Optional[Sequence[str]] = None
+    ids: Optional[Sequence[str]] = None
+    onlyWithVersions: Optional[bool] = None
+    search: Optional[str] = None
+    sourceApps: Optional[Sequence[str]] = None
+
+
+class ProjectUpdateInput(BaseModel):
+    id: str
+    name: Optional[str] = None
+    description: Optional[str] = None
+    allowPublicComments: Optional[bool] = None
+    visibility: Optional[ProjectVisibility] = None
+
+
+class ProjectUpdateRoleInput(BaseModel):
+    userId: str
+    projectId: str
+    role: Optional[str]

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

@@ -0,0 +1,15 @@
+from typing import Optional, Sequence
+
+from pydantic import BaseModel
+
+
+class UserUpdateInput(BaseModel):
+    avatar: Optional[str] = None
+    bio: Optional[str] = None
+    company: Optional[str] = None
+    name: Optional[str] = None
+
+
+class UserProjectsFilter(BaseModel):
+    search: str
+    onlyWithRoles: Optional[Sequence[str]] = None

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

@@ -0,0 +1,37 @@
+from typing import Optional, Sequence
+
+from pydantic import BaseModel
+
+
+class UpdateVersionInput(BaseModel):
+    versionId: str
+    projectId: str
+    message: Optional[str]
+
+
+class MoveVersionsInput(BaseModel):
+    targetModelName: str
+    versionIds: Sequence[str]
+    projectId: str
+
+
+class DeleteVersionsInput(BaseModel):
+    versionIds: Sequence[str]
+    projectId: str
+
+
+class CreateVersionInput(BaseModel):
+    objectId: str
+    modelId: str
+    projectId: str
+    message: Optional[str] = None
+    sourceApplication: Optional[str] = "py"
+    totalChildrenCount: Optional[int] = None
+    parents: Optional[Sequence[str]] = None
+
+
+class MarkReceivedVersionInput(BaseModel):
+    versionId: str
+    projectId: str
+    sourceApplication: str
+    message: Optional[str] = None

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

@@ -0,0 +1,71 @@
+from specklepy.core.api.models.current import (
+    AuthStrategy,
+    LimitedUser,
+    Model,
+    ModelWithVersions,
+    PendingStreamCollaborator,
+    Project,
+    ProjectCollaborator,
+    ProjectCommentCollection,
+    ProjectWithModels,
+    ProjectWithTeam,
+    ResourceCollection,
+    ServerConfiguration,
+    ServerInfo,
+    ServerMigration,
+    User,
+    UserSearchResultCollection,
+    Version,
+)
+from specklepy.core.api.models.deprecated import (
+    Activity,
+    ActivityCollection,
+    Branch,
+    Branches,
+    Collaborator,
+    Commit,
+    Commits,
+    Object,
+    Stream,
+    Streams,
+)
+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",
+    "ProjectWithTeam",
+    "ProjectCommentCollection",
+    "UserSearchResultCollection",
+    "UserProjectsUpdatedMessage",
+    "ProjectModelsUpdatedMessage",
+    "ProjectUpdatedMessage",
+    "ProjectVersionsUpdatedMessage",
+    "Collaborator",
+    "Commit",
+    "Commits",
+    "Object",
+    "Branch",
+    "Branches",
+    "Stream",
+    "Streams",
+    "Activity",
+    "ActivityCollection",
+]

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

@@ -0,0 +1,172 @@
+from datetime import datetime
+from typing import Generic, List, Optional, TypeVar
+
+from pydantic import BaseModel
+
+from specklepy.core.api.enums import ProjectVisibility
+from specklepy.core.api.models.deprecated import Streams
+
+T = TypeVar("T")
+
+
+class User(BaseModel):
+    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
+    streams: Optional["Streams"] = 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(BaseModel, Generic[T]):
+    totalCount: int
+    items: List[T]
+    cursor: Optional[str] = None
+
+
+class ServerMigration(BaseModel):
+    movedFrom: Optional[str]
+    movedTo: Optional[str]
+
+
+class AuthStrategy(BaseModel):
+    color: Optional[str]
+    icon: str
+    id: str
+    name: str
+    url: str
+
+
+class ServerConfiguration(BaseModel):
+    blobSizeLimitBytes: int
+    objectMultipartUploadSizeLimitBytes: int
+    objectSizeLimitBytes: int
+
+
+# Keeping this one all Optionals at the minute,
+#  because its used both as a deserialization model for GQL and Account Management
+class ServerInfo(BaseModel):
+    name: Optional[str] = None
+    company: Optional[str] = None
+    url: Optional[str] = None
+    adminContact: Optional[str] = None
+    description: Optional[str] = None
+    canonicalUrl: Optional[str] = None
+    roles: Optional[List[dict]] = None
+    scopes: Optional[List[dict]] = None
+    authStrategies: Optional[List[dict]] = None
+    version: Optional[str] = None
+    frontend2: Optional[bool] = None
+    migration: Optional[ServerMigration] = None
+
+    # TODO separate gql model from account management model
+
+
+class LimitedUser(BaseModel):
+    """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]
+
+
+class PendingStreamCollaborator(BaseModel):
+    id: str
+    inviteId: str
+    streamId: Optional[str] = None
+    projectId: str
+    streamName: Optional[str] = None
+    projectName: str
+    title: str
+    role: str
+    invitedBy: LimitedUser
+    user: Optional[LimitedUser] = None
+    token: Optional[str]
+
+    def __repr__(self):
+        return (
+            f"PendingStreamCollaborator( inviteId: {self.inviteId}, streamId:"
+            f" {self.streamId}, 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(BaseModel):
+    id: str
+    role: str
+    user: LimitedUser
+
+
+class Version(BaseModel):
+    authorUser: Optional[LimitedUser]
+    createdAt: datetime
+    id: str
+    message: Optional[str]
+    previewUrl: str
+    referencedObject: str
+    sourceApplication: Optional[str]
+
+
+class Model(BaseModel):
+    author: Optional[LimitedUser]
+    createdAt: datetime
+    description: Optional[str]
+    displayName: str
+    id: str
+    name: str
+    previewUrl: Optional[str]
+    updatedAt: datetime
+
+
+class ModelWithVersions(Model):
+    versions: ResourceCollection[Version]
+
+
+class Project(BaseModel):
+    allowPublicComments: bool
+    createdAt: datetime
+    description: Optional[str]
+    id: str
+    name: str
+    role: Optional[str]
+    sourceApps: List[str]
+    updatedAt: datetime
+    visibility: ProjectVisibility
+    workspaceId: Optional[str]
+
+
+class ProjectWithModels(Project):
+    models: ResourceCollection[Model]
+
+
+class ProjectWithTeam(Project):
+    invitedTeam: List[PendingStreamCollaborator]
+    team: List[ProjectCollaborator]
+
+
+class ProjectCommentCollection(ResourceCollection[T], Generic[T]):
+    totalArchivedCount: int
+
+
+class UserSearchResultCollection(BaseModel):
+    items: List[LimitedUser]
+    cursor: Optional[str] = None

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

@@ -1,9 +1,17 @@
 from datetime import datetime
 from typing import List, Optional
 
+from deprecated import deprecated
 from pydantic import BaseModel, Field
 
+FE1_DEPRECATION_REASON = (
+    "Stream/Branch/Commit API is now deprecated, "
+    "Use the new Project/Model/Version API functions in Client"
+)
+FE1_DEPRECATION_VERSION = "2.20"
 
+
+@deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
 class Collaborator(BaseModel):
     id: Optional[str] = None
     name: Optional[str] = None
@@ -11,6 +19,7 @@ class Collaborator(BaseModel):
     avatar: Optional[str] = None
 
 
+@deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
 class Commit(BaseModel):
     id: Optional[str] = None
     message: Optional[str] = None
@@ -35,12 +44,14 @@ class Commit(BaseModel):
         return self.__repr__()
 
 
+@deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
 class Commits(BaseModel):
     totalCount: Optional[int] = None
     cursor: Optional[datetime] = None
     items: List[Commit] = []
 
 
+@deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
 class Object(BaseModel):
     id: Optional[str] = None
     speckleType: Optional[str] = None
@@ -49,6 +60,7 @@ class Object(BaseModel):
     createdAt: Optional[datetime] = None
 
 
+@deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
 class Branch(BaseModel):
     id: Optional[str] = None
     name: Optional[str] = None
@@ -56,12 +68,14 @@ class Branch(BaseModel):
     commits: Optional[Commits] = None
 
 
+@deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
 class Branches(BaseModel):
     totalCount: Optional[int] = None
     cursor: Optional[datetime] = None
     items: List[Branch] = []
 
 
+@deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
 class Stream(BaseModel):
     id: Optional[str] = None
     name: Optional[str] = None
@@ -88,67 +102,14 @@ class Stream(BaseModel):
         return self.__repr__()
 
 
+@deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
 class Streams(BaseModel):
     totalCount: Optional[int] = None
     cursor: Optional[datetime] = None
     items: List[Stream] = []
 
 
-class User(BaseModel):
-    id: Optional[str] = None
-    email: Optional[str] = None
-    name: Optional[str] = None
-    bio: Optional[str] = None
-    company: Optional[str] = None
-    avatar: Optional[str] = None
-    verified: Optional[bool] = None
-    role: Optional[str] = None
-    streams: Optional[Streams] = 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 LimitedUser(BaseModel):
-    """Limited user type, for showing public info about a user to another user."""
-
-    id: str
-    name: Optional[str] = None
-    bio: Optional[str] = None
-    company: Optional[str] = None
-    avatar: Optional[str] = None
-    verified: Optional[bool] = None
-    role: Optional[str] = None
-
-
-class PendingStreamCollaborator(BaseModel):
-    id: Optional[str] = None
-    inviteId: Optional[str] = None
-    streamId: Optional[str] = None
-    streamName: Optional[str] = None
-    title: Optional[str] = None
-    role: Optional[str] = None
-    invitedBy: Optional[User] = None
-    user: Optional[User] = None
-    token: Optional[str] = None
-
-    def __repr__(self):
-        return (
-            f"PendingStreamCollaborator( inviteId: {self.inviteId}, streamId:"
-            f" {self.streamId}, role: {self.role}, title: {self.title}, invitedBy:"
-            f" {self.user.name if self.user else None})"
-        )
-
-    def __str__(self) -> str:
-        return self.__repr__()
-
-
+@deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
 class Activity(BaseModel):
     actionType: Optional[str] = None
     info: Optional[dict] = None
@@ -169,6 +130,7 @@ class Activity(BaseModel):
         return self.__repr__()
 
 
+@deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
 class ActivityCollection(BaseModel):
     totalCount: Optional[int] = None
     items: Optional[List[Activity]] = None
@@ -183,16 +145,3 @@ class ActivityCollection(BaseModel):
 
     def __str__(self) -> str:
         return self.__repr__()
-
-
-class ServerInfo(BaseModel):
-    name: Optional[str] = None
-    company: Optional[str] = None
-    url: Optional[str] = None
-    description: Optional[str] = None
-    adminContact: Optional[str] = None
-    canonicalUrl: Optional[str] = None
-    roles: Optional[List[dict]] = None
-    scopes: Optional[List[dict]] = None
-    authStrategies: Optional[List[dict]] = None
-    version: Optional[str] = None

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

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

src/specklepy/core/api/operations.py

@@ -1,6 +1,6 @@
 from typing import List, Optional
 
-#from specklepy.logging import metrics
+# from specklepy.logging import metrics
 from specklepy.logging.exceptions import SpeckleException
 from specklepy.objects.base import Base
 from specklepy.serialization.base_object_serializer import BaseObjectSerializer
@@ -70,7 +70,8 @@ def receive(
 
     serializer = BaseObjectSerializer(read_transport=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
+    # 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)
@@ -90,7 +91,9 @@ 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
@@ -104,6 +107,8 @@ def serialize(base: Base, write_transports: List[AbstractTransport] = []) -> str
     Returns:
         str -- the serialized object
     """
+    if not write_transports:
+        write_transports = []
     serializer = BaseObjectSerializer(write_transports=write_transports)
 
     return serializer.write_json(base)[1]

src/specklepy/core/api/resource.py

@@ -1,9 +1,10 @@
 from threading import Lock
-from typing import Any, Dict, List, Optional, Tuple, Type, Union
+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 (
@@ -14,8 +15,10 @@ from specklepy.logging.exceptions import (
 from specklepy.serialization.base_object_serializer import BaseObjectSerializer
 from specklepy.transports.sqlite import SQLiteTransport
 
+T = TypeVar("T", bound=BaseModel)
 
-class ResourceBase(object):
+
+class ResourceBase:
     def __init__(
         self,
         account: Account,
@@ -43,6 +46,35 @@ class ResourceBase(object):
                 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:
@@ -69,6 +101,9 @@ class ResourceBase(object):
         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)

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

@@ -0,0 +1,43 @@
+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.deprecated import (
+    active_user,
+    branch,
+    commit,
+    object,
+    other_user,
+    server,
+    stream,
+    subscriptions,
+    user,
+)
+
+__all__ = [
+    "ActiveUserResource",
+    "ModelResource",
+    "OtherUserResource",
+    "ProjectInviteResource",
+    "ProjectResource",
+    "ServerResource",
+    "SubscriptionResource",
+    "VersionResource",
+    "active_user",
+    "branch",
+    "commit",
+    "object",
+    "other_user",
+    "server",
+    "stream",
+    "subscriptions",
+    "user",
+]

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

@@ -1,17 +1,30 @@
 from datetime import datetime, timezone
-from typing import List, Optional
+from typing import List, Optional, overload
 
+from deprecated import deprecated
 from gql import gql
 
-from specklepy.core.api.models import ActivityCollection, PendingStreamCollaborator, User
+from specklepy.core.api.inputs.user_inputs import UserProjectsFilter, UserUpdateInput
+from specklepy.core.api.models import (
+    ActivityCollection,
+    PendingStreamCollaborator,
+    Project,
+    ResourceCollection,
+    User,
+)
+from specklepy.core.api.models.deprecated import (
+    FE1_DEPRECATION_REASON,
+    FE1_DEPRECATION_VERSION,
+)
 from specklepy.core.api.resource import ResourceBase
-from specklepy.logging.exceptions import SpeckleException
+from specklepy.core.api.responses import DataResponse
+from specklepy.logging.exceptions import GraphQLException
 
 NAME = "active_user"
 
 
-class Resource(ResourceBase):
-    """API Access class for users"""
+class ActiveUserResource(ResourceBase):
+    """API Access class for the active user"""
 
     def __init__(self, account, basepath, client, server_version) -> None:
         super().__init__(
@@ -23,38 +36,75 @@ class Resource(ResourceBase):
         )
         self.schema = User
 
-    def get(self) -> 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
+    def get(self) -> Optional[User]:
+        """Gets the currently active user profile
+        (as extracted from the authorization header)
 
         Returns:
-            User -- the retrieved user
+            User -- the requested user, or none if no authentication token
+            is provided to the Client
         """
-        query = gql(
+        QUERY = gql(
             """
             query User {
-                activeUser {
-                    id
-                    email
-                    name
-                    bio
-                    company
-                    avatar
-                    verified
-                    profiles
-                    role
-                }
-            }
-          """
+             data:activeUser {
+               id
+               email
+               name
+               bio
+               company
+               avatar
+               verified
+               role
+             }
+           }
+           """
         )
 
-        params = {}
+        variables = {}
 
-        return self.make_request(query=query, params=params, return_type="activeUser")
+        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")}
+
+        return self.make_request_and_parse_response(
+            DataResponse[DataResponse[User]], QUERY, variables
+        ).data.data
+
+    @deprecated("Use UserUpdateInput overload", version=FE1_DEPRECATION_VERSION)
+    @overload
+    def update(
+        self,
+        name: Optional[str] = None,
+        company: Optional[str] = None,
+        bio: Optional[str] = None,
+        avatar: Optional[str] = None,
+    ) -> User: ...
+
+    @overload
+    def update(self, *, input: UserUpdateInput) -> User: ...
 
     def update(
         self,
@@ -62,40 +112,125 @@ class Resource(ResourceBase):
         company: Optional[str] = None,
         bio: Optional[str] = None,
         avatar: Optional[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    @deprecated(version=DEPRECATION_VERSION, reason=DEPRECATION_TEXT):
-            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"
+        *,
+        input: Optional[UserUpdateInput] = None,
+    ) -> User:
+        if isinstance(input, UserUpdateInput):
+            return self._update(input=input)
+        else:
+            return self._update(
+                input=UserUpdateInput(
+                    name=name,
+                    company=company,
+                    bio=bio,
+                    avatar=avatar,
                 )
             )
 
-        return self.make_request(
-            query=query, params=params, return_type="userUpdate", parse_response=False
+    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") 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
+
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def activity(
         self,
         limit: int = 20,
@@ -103,7 +238,7 @@ class Resource(ResourceBase):
         before: Optional[datetime] = None,
         after: Optional[datetime] = None,
         cursor: Optional[datetime] = None,
-    ):
+    ) -> ActivityCollection:
         """
         Get the activity from a given stream in an Activity collection.
         Step into the activity `items` for the list of activity.
@@ -174,6 +309,7 @@ class Resource(ResourceBase):
             schema=ActivityCollection,
         )
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def get_all_pending_invites(self) -> List[PendingStreamCollaborator]:
         """Get all of the active user's pending stream invites
 
@@ -194,13 +330,18 @@ class Resource(ResourceBase):
                     inviteId
                     streamId
                     streamName
+                    projectId
+                    projectName
                     title
                     role
                     invitedBy {
                         id
                         name
+                        bio
                         company
                         avatar
+                        verified
+                        role
                     }
                 }
             }
@@ -213,6 +354,7 @@ class Resource(ResourceBase):
             schema=PendingStreamCollaborator,
         )
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def get_pending_invite(
         self, stream_id: str, token: Optional[str] = None
     ) -> Optional[PendingStreamCollaborator]:
@@ -237,15 +379,21 @@ class Resource(ResourceBase):
                 streamInvite(streamId: $streamId, token: $token) {
                     id
                     token
+                    inviteId
                     streamId
                     streamName
+                    projectId
+                    projectName
                     title
                     role
                     invitedBy {
                         id
                         name
+                        bio
                         company
                         avatar
+                        verified
+                        role
                     }
                 }
             }

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

@@ -0,0 +1,299 @@
+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")
+                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") 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"),
+        }
+
+        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")}
+
+        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"),
+        }
+
+        return self.make_request_and_parse_response(
+            DataResponse[DataResponse[Model]], QUERY, variables
+        ).data.data

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

@@ -1,16 +1,26 @@
 from datetime import datetime, timezone
 from typing import List, Optional, Union
 
+from deprecated import deprecated
 from gql import gql
 
-from specklepy.core.api.models import ActivityCollection, LimitedUser
+from specklepy.core.api.models import (
+    ActivityCollection,
+    LimitedUser,
+    UserSearchResultCollection,
+)
+from specklepy.core.api.models.deprecated import (
+    FE1_DEPRECATION_REASON,
+    FE1_DEPRECATION_VERSION,
+)
 from specklepy.core.api.resource import ResourceBase
+from specklepy.core.api.responses import DataResponse
 from specklepy.logging.exceptions import SpeckleException
 
 NAME = "other_user"
 
 
-class Resource(ResourceBase):
+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:
@@ -23,7 +33,7 @@ class Resource(ResourceBase):
         )
         self.schema = LimitedUser
 
-    def get(self, id: str) -> LimitedUser:
+    def get(self, id: str) -> Optional[LimitedUser]:
         """
         Gets the profile of another user.
 
@@ -33,26 +43,95 @@ class Resource(ResourceBase):
         Returns:
             LimitedUser -- the retrieved profile of another user
         """
-        query = gql(
+        QUERY = gql(
             """
-            query OtherUser($id: String!) {
-                otherUser(id: $id) {
-                    id
-                    name
-                    bio
-                    company
-                    avatar
-                    verified
-                    role
-                }
+          query LimitedUser($id: String!) {
+            data:otherUser(id: $id){
+              id
+              name
+              bio
+              company
+              avatar
+              verified
+              role
             }
+          }
           """
         )
 
-        params = {"id": id}
+        variables = {"id": id}
 
-        return self.make_request(query=query, params=params, return_type="otherUser")
+        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
+
+    @deprecated(reason="Use user_search instead", version=FE1_DEPRECATION_VERSION)
     def search(
         self, search_query: str, limit: int = 25
     ) -> Union[List[LimitedUser], SpeckleException]:
@@ -75,12 +154,13 @@ class Resource(ResourceBase):
             query UserSearch($search_query: String!, $limit: Int!) {
                 userSearch(query: $search_query, limit: $limit) {
                     items {
-                        id
-                        name
-                        bio
-                        company
-                        avatar
-                        verified
+                      id
+                      name
+                      bio
+                      company
+                      avatar
+                      verified
+                      role
                     }
                 }
             }
@@ -92,6 +172,7 @@ class Resource(ResourceBase):
             query=query, params=params, return_type=["userSearch", "items"]
         )
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def activity(
         self,
         user_id: str,

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"),
+        }
+
+        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"),
+        }
+
+        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,345 @@
+from typing import Optional
+
+from gql import gql
+
+from specklepy.core.api.inputs.project_inputs import (
+    ProjectCreateInput,
+    ProjectModelsFilter,
+    ProjectUpdateInput,
+    ProjectUpdateRoleInput,
+)
+from specklepy.core.api.models import Project, ProjectWithModels, ProjectWithTeam
+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_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") 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:
+        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"),
+        }
+
+        return self.make_request_and_parse_response(
+            DataResponse[DataResponse[Project]], QUERY, variables
+        ).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"),
+        }
+
+        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"),
+        }
+
+        return self.make_request_and_parse_response(
+            DataResponse[DataResponse[ProjectWithTeam]], QUERY, variables
+        ).data.data

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

@@ -1,6 +1,7 @@
 import re
 from typing import Any, Dict, List, Tuple
 
+import requests
 from gql import gql
 
 from specklepy.core.api.models import ServerInfo
@@ -10,7 +11,7 @@ from specklepy.logging.exceptions import GraphQLException
 NAME = "server"
 
 
-class Resource(ResourceBase):
+class ServerResource(ResourceBase):
     """API Access class for the server"""
 
     def __init__(self, account, basepath, client) -> None:
@@ -56,9 +57,21 @@ class Resource(ResourceBase):
             """
         )
 
-        return self.make_request(
+        server_info = self.make_request(
             query=query, return_type="serverInfo", schema=ServerInfo
         )
+        if isinstance(server_info, ServerInfo) and isinstance(
+            server_info.canonicalUrl, str
+        ):
+            r = requests.get(
+                server_info.canonicalUrl, headers={"User-Agent": "specklepy SDK"}
+            )
+            if "x-speckle-frontend-2" in r.headers:
+                server_info.frontend2 = True
+            else:
+                server_info.frontend2 = False
+
+        return server_info
 
     def version(self) -> Tuple[Any, ...]:
         """Get the server version
@@ -67,7 +80,8 @@ class Resource(ResourceBase):
             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
+        # not tracking as it will be called along with other mutations / queries
+        # as a check
         query = gql(
             """
             query 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,240 @@
+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") 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) -> str:
+        QUERY = gql(
+            """
+            mutation Create($input: CreateVersionInput!) {
+              data:versionMutations {
+                data:create(input: $input) {
+                  data:id
+                }
+              }
+            }
+            """
+        )
+
+        variables = {
+            "input": input.model_dump(warnings="error"),
+        }
+
+        return self.make_request_and_parse_response(
+            DataResponse[DataResponse[DataResponse[str]]], QUERY, variables
+        ).data.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")}
+
+        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"),
+        }
+
+        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"),
+        }
+
+        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"),
+        }
+
+        return self.make_request_and_parse_response(
+            DataResponse[DataResponse[bool]], QUERY, variables
+        ).data.data

src/specklepy/core/api/resources/deprecated/active_user.py

@@ -0,0 +1,15 @@
+from deprecated import deprecated
+
+from specklepy.core.api.models.deprecated import FE1_DEPRECATION_VERSION
+from specklepy.core.api.resources import ActiveUserResource
+
+
+@deprecated(
+    reason="Class renamed to ActiveUserResource", version=FE1_DEPRECATION_VERSION
+)
+class Resource(ActiveUserResource):
+    """
+    Class renamed to ActiveUserResource
+    """
+
+    pass

src/specklepy/core/api/resources/deprecated/branch.py

@@ -1,15 +1,24 @@
 from typing import Optional
 
+from deprecated import deprecated
 from gql import gql
 
-from specklepy.core.api.models import Branch
+from specklepy.core.api.models.deprecated import (
+    FE1_DEPRECATION_REASON,
+    FE1_DEPRECATION_VERSION,
+    Branch,
+)
 from specklepy.core.api.resource import ResourceBase
+from specklepy.logging.exceptions import SpeckleException
 
 NAME = "branch"
 
 
 class Resource(ResourceBase):
-    """API Access class for branches"""
+    """
+    API Access class for branches
+    Branch resource is deprecated, please use model resource instead
+    """
 
     def __init__(self, account, basepath, client) -> None:
         super().__init__(
@@ -20,6 +29,7 @@ class Resource(ResourceBase):
         )
         self.schema = Branch
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def create(
         self, stream_id: str, name: str, description: str = "No description provided"
     ) -> str:
@@ -39,6 +49,8 @@ class Resource(ResourceBase):
             }
           """
         )
+        if len(name) < 3:
+            return SpeckleException(message="Branch Name must be at least 3 characters")
         params = {
             "branch": {
                 "streamId": stream_id,
@@ -51,6 +63,7 @@ class Resource(ResourceBase):
             query=query, params=params, return_type="branchCreate", parse_response=False
         )
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def get(self, stream_id: str, name: str, commits_limit: int = 10):
         """Get a branch by name from a stream
 
@@ -98,6 +111,7 @@ class Resource(ResourceBase):
             query=query, params=params, return_type=["stream", "branch"]
         )
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def list(self, stream_id: str, branches_limit: int = 10, commits_limit: int = 10):
         """Get a list of branches from a given stream
 
@@ -153,6 +167,7 @@ class Resource(ResourceBase):
             query=query, params=params, return_type=["stream", "branches", "items"]
         )
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def update(
         self,
         stream_id: str,
@@ -194,6 +209,7 @@ class Resource(ResourceBase):
             query=query, params=params, return_type="branchUpdate", parse_response=False
         )
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def delete(self, stream_id: str, branch_id: str):
         """Delete a branch
 

src/specklepy/core/api/resources/deprecated/commit.py

@@ -1,8 +1,13 @@
 from typing import List, Optional, Union
 
+from deprecated import deprecated
 from gql import gql
 
-from specklepy.core.api.models import Commit
+from specklepy.core.api.models.deprecated import (
+    FE1_DEPRECATION_REASON,
+    FE1_DEPRECATION_VERSION,
+    Commit,
+)
 from specklepy.core.api.resource import ResourceBase
 from specklepy.logging.exceptions import SpeckleException
 
@@ -10,7 +15,10 @@ NAME = "commit"
 
 
 class Resource(ResourceBase):
-    """API Access class for commits"""
+    """
+    API Access class for commits
+    Commit resource is deprecated, please use version resource instead
+    """
 
     def __init__(self, account, basepath, client) -> None:
         super().__init__(
@@ -21,6 +29,7 @@ class Resource(ResourceBase):
         )
         self.schema = Commit
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def get(self, stream_id: str, commit_id: str) -> Commit:
         """
         Gets a commit given a stream and the commit id
@@ -59,6 +68,7 @@ class Resource(ResourceBase):
             query=query, params=params, return_type=["stream", "commit"]
         )
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def list(self, stream_id: str, limit: int = 10) -> List[Commit]:
         """
         Get a list of commits on a given stream
@@ -100,6 +110,7 @@ class Resource(ResourceBase):
             query=query, params=params, return_type=["stream", "commits", "items"]
         )
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def create(
         self,
         stream_id: str,
@@ -149,6 +160,7 @@ class Resource(ResourceBase):
             query=query, params=params, return_type="commitCreate", parse_response=False
         )
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def update(self, stream_id: str, commit_id: str, message: str) -> bool:
         """
         Update a commit
@@ -176,6 +188,7 @@ class Resource(ResourceBase):
             query=query, params=params, return_type="commitUpdate", parse_response=False
         )
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def delete(self, stream_id: str, commit_id: str) -> bool:
         """
         Delete a commit
@@ -200,6 +213,7 @@ class Resource(ResourceBase):
             query=query, params=params, return_type="commitDelete", parse_response=False
         )
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def received(
         self,
         stream_id: str,

src/specklepy/core/api/resources/deprecated/other_user.py

@@ -0,0 +1,15 @@
+from deprecated import deprecated
+
+from specklepy.core.api.models.deprecated import FE1_DEPRECATION_VERSION
+from specklepy.core.api.resources import OtherUserResource
+
+
+@deprecated(
+    reason="Class renamed to OtherUserResource", version=FE1_DEPRECATION_VERSION
+)
+class Resource(OtherUserResource):
+    """
+    Class renamed to OtherUserResource
+    """
+
+    pass

src/specklepy/core/api/resources/deprecated/server.py

@@ -0,0 +1,11 @@
+from deprecated import deprecated
+
+from specklepy.core.api.models.deprecated import FE1_DEPRECATION_VERSION
+from specklepy.core.api.resources import ServerResource
+
+NAME = "server"
+
+
+@deprecated(reason="Renamed to ServerResource", version=FE1_DEPRECATION_VERSION)
+class Resource(ServerResource):
+    """API Access class for the server"""

src/specklepy/core/api/resources/deprecated/stream.py

@@ -4,7 +4,15 @@ from typing import List, Optional
 from deprecated import deprecated
 from gql import gql
 
-from specklepy.core.api.models import ActivityCollection, PendingStreamCollaborator, Stream
+from specklepy.core.api.models import (
+    ActivityCollection,
+    PendingStreamCollaborator,
+    Stream,
+)
+from specklepy.core.api.models.deprecated import (
+    FE1_DEPRECATION_REASON,
+    FE1_DEPRECATION_VERSION,
+)
 from specklepy.core.api.resource import ResourceBase
 from specklepy.logging.exceptions import SpeckleException, UnsupportedException
 
@@ -12,7 +20,10 @@ NAME = "stream"
 
 
 class Resource(ResourceBase):
-    """API Access class for streams"""
+    """
+    API Access class for streams
+    Stream resource is deprecated, please use project resource instead
+    """
 
     def __init__(self, account, basepath, client, server_version) -> None:
         super().__init__(
@@ -25,6 +36,7 @@ class Resource(ResourceBase):
 
         self.schema = Stream
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def get(self, id: str, branch_limit: int = 10, commit_limit: int = 10) -> Stream:
         """Get the specified stream from the server
 
@@ -86,6 +98,7 @@ class Resource(ResourceBase):
 
         return self.make_request(query=query, params=params, return_type="stream")
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def list(self, stream_limit: int = 10) -> List[Stream]:
         """Get a list of the user's streams
 
@@ -98,7 +111,7 @@ class Resource(ResourceBase):
         query = gql(
             """
             query User($stream_limit: Int!) {
-                user {
+                activeUser {
                     id
                     bio
                     name
@@ -136,9 +149,10 @@ class Resource(ResourceBase):
         params = {"stream_limit": stream_limit}
 
         return self.make_request(
-            query=query, params=params, return_type=["user", "streams", "items"]
+            query=query, params=params, return_type=["activeUser", "streams", "items"]
         )
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def create(
         self,
         name: str = "Anonymous Python Stream",
@@ -163,7 +177,8 @@ class Resource(ResourceBase):
             }
         """
         )
-
+        if len(name) < 3 and len(name) != 0:
+            return SpeckleException(message="Stream Name must be at least 3 characters")
         params = {
             "stream": {"name": name, "description": description, "isPublic": is_public}
         }
@@ -172,6 +187,7 @@ class Resource(ResourceBase):
             query=query, params=params, return_type="streamCreate", parse_response=False
         )
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def update(
         self,
         id: str,
@@ -212,6 +228,7 @@ class Resource(ResourceBase):
             query=query, params=params, return_type="streamUpdate", parse_response=False
         )
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def delete(self, id: str) -> bool:
         """Delete a stream given its id
 
@@ -235,6 +252,7 @@ class Resource(ResourceBase):
             query=query, params=params, return_type="streamDelete", parse_response=False
         )
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def search(
         self,
         search_query: str,
@@ -314,6 +332,7 @@ class Resource(ResourceBase):
             query=query, params=params, return_type=["streams", "items"]
         )
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def favorite(self, stream_id: str, favorited: bool = True):
         """Favorite or unfavorite the given stream.
 
@@ -347,6 +366,7 @@ class Resource(ResourceBase):
             query=query, params=params, return_type=["streamFavorite"]
         )
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def get_all_pending_invites(
         self, stream_id: str
     ) -> List[PendingStreamCollaborator]:
@@ -374,19 +394,27 @@ class Resource(ResourceBase):
                         inviteId
                         streamId
                         streamName
+                        projectName
+                        projectId
                         title
                         role
                         invitedBy{
                             id
                             name
+                            bio
                             company
                             avatar
+                            verified
+                            role
                         }
                         user {
                             id
                             name
+                            bio
                             company
                             avatar
+                            verified
+                            role
                         }
                     }
                 }
@@ -402,6 +430,7 @@ class Resource(ResourceBase):
             schema=PendingStreamCollaborator,
         )
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def invite(
         self,
         stream_id: str,
@@ -458,6 +487,7 @@ class Resource(ResourceBase):
             parse_response=False,
         )
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def invite_batch(
         self,
         stream_id: str,
@@ -504,11 +534,10 @@ class Resource(ResourceBase):
 
         user_invites = [
             {"streamId": stream_id, "message": message, "userId": user_id}
-            for user_id in (user_ids if user_ids is not None else []) 
+            for user_id in (user_ids if user_ids is not None else [])
             if user_id is not None
         ]
 
-
         params = {"input": [*email_invites, *user_invites]}
 
         return self.make_request(
@@ -518,6 +547,7 @@ class Resource(ResourceBase):
             parse_response=False,
         )
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def invite_cancel(self, stream_id: str, invite_id: str) -> bool:
         """Cancel an existing stream invite
 
@@ -549,6 +579,7 @@ class Resource(ResourceBase):
             parse_response=False,
         )
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def invite_use(self, stream_id: str, token: str, accept: bool = True) -> bool:
         """Accept or decline a stream invite
 
@@ -586,6 +617,7 @@ class Resource(ResourceBase):
             parse_response=False,
         )
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def update_permission(self, stream_id: str, user_id: str, role: str):
         """Updates permissions for a user on a given stream
 
@@ -632,6 +664,7 @@ class Resource(ResourceBase):
             parse_response=False,
         )
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def revoke_permission(self, stream_id: str, user_id: str):
         """Revoke permissions from a user on a given stream
 
@@ -661,6 +694,7 @@ class Resource(ResourceBase):
             parse_response=False,
         )
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def activity(
         self,
         stream_id: str,
@@ -728,13 +762,13 @@ class Resource(ResourceBase):
                 "stream_id": stream_id,
                 "limit": limit,
                 "action_type": action_type,
-                "before": before.astimezone(timezone.utc).isoformat()
-                if before
-                else before,
+                "before": (
+                    before.astimezone(timezone.utc).isoformat() if before else before
+                ),
                 "after": after.astimezone(timezone.utc).isoformat() if after else after,
-                "cursor": cursor.astimezone(timezone.utc).isoformat()
-                if cursor
-                else cursor,
+                "cursor": (
+                    cursor.astimezone(timezone.utc).isoformat() if cursor else cursor
+                ),
             }
         except AttributeError as e:
             raise SpeckleException(

src/specklepy/core/api/resources/deprecated/subscriptions.py

@@ -1,11 +1,16 @@
 from functools import wraps
 from typing import Callable, Dict, List, Optional, Union
 
+from deprecated import deprecated
 from gql import gql
 from graphql import DocumentNode
 
+from specklepy.core.api.models.deprecated import (
+    FE1_DEPRECATION_REASON,
+    FE1_DEPRECATION_VERSION,
+    Stream,
+)
 from specklepy.core.api.resource import ResourceBase
-from specklepy.core.api.resources.stream import Stream
 from specklepy.logging.exceptions import SpeckleException
 
 NAME = "subscribe"
@@ -35,6 +40,7 @@ class Resource(ResourceBase):
             name=NAME,
         )
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     @check_wsclient
     async def stream_added(self, callback: Optional[Callable] = None):
         """Subscribes to new stream added event for your profile.

src/specklepy/core/api/resources/deprecated/user.py

@@ -4,9 +4,12 @@ from typing import List, Optional, Union
 from deprecated import deprecated
 from gql import gql
 
-from specklepy.core.api.models import ActivityCollection, PendingStreamCollaborator, User
+from specklepy.core.api.models import (
+    ActivityCollection,
+    PendingStreamCollaborator,
+    User,
+)
 from specklepy.core.api.resource import ResourceBase
-
 from specklepy.logging.exceptions import SpeckleException
 
 NAME = "user"

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

src/specklepy/core/api/wrapper.py

@@ -1,12 +1,13 @@
-from urllib.parse import unquote, urlparse
+from urllib.parse import quote, unquote, urlparse
 from warnings import warn
+
 from gql import gql
 
 from specklepy.core.api.client import SpeckleClient
 from specklepy.core.api.credentials import (
     Account,
     get_account_from_token,
-    get_local_accounts,
+    get_accounts_for_server,
 )
 from specklepy.logging.exceptions import SpeckleException, SpeckleWarning
 from specklepy.transports.server.server import ServerTransport
@@ -29,7 +30,7 @@ class StreamWrapper:
     from specklepy.api.wrapper import StreamWrapper
 
     # provide any stream, branch, commit, object, or globals url
-    wrapper = StreamWrapper("https://speckle.xyz/streams/3073b96e86/commits/604bea8cc6")
+    wrapper = StreamWrapper("https://app.speckle.systems/streams/3073b96e86/commits/604bea8cc6")
 
     # get an authenticated SpeckleClient if you have a local account for the server
     client = wrapper.get_client()
@@ -46,6 +47,7 @@ class StreamWrapper:
     commit_id: str = None
     object_id: str = None
     branch_name: str = None
+    model_id: str = None
     _client: SpeckleClient = None
     _account: Account = None
 
@@ -85,45 +87,58 @@ class StreamWrapper:
         # check for fe2 URL
         if "/projects/" in parsed.path:
             use_fe2 = True
+            key_stream = "project"
         else:
             use_fe2 = False
+            key_stream = "stream"
 
         while segments:
             segment = segments.pop(0)
-            if segments and (
-                (use_fe2 is False and segment.lower() == "streams")
-                or (use_fe2 is True and segment.lower() == "projects")
-            ):
-                self.stream_id = segments.pop(0)
-            elif segments and segment.lower() == "commits":
-                self.commit_id = segments.pop(0)
-            elif segments and (
-                (use_fe2 is False and segment.lower() == "branches")
-                or (use_fe2 is True and segment.lower() == "models")
-            ):
-                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:
+
+            if use_fe2 is False:
+                if segments and segment.lower() == "streams":
+                    self.stream_id = segments.pop(0)
+                elif segments and segment.lower() == "commits":
                     self.commit_id = segments.pop(0)
-            else:
-                raise SpeckleException(
-                    f"Cannot parse {url} into a stream wrapper class - invalid URL"
-                    " provided."
-                )
+                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."
+                    )
+            elif segments and use_fe2 is True:
+                if segment.lower() == "projects":
+                    self.stream_id = segments.pop(0)
+                elif segment.lower() == "models":
+                    next_segment = segments.pop(0)
+                    if "," in next_segment:
+                        raise SpeckleException("Multi-model urls are not supported yet")
+                    elif unquote(next_segment).startswith("$"):
+                        raise SpeckleException(
+                            "Federation model urls are not supported"
+                        )
+                    elif len(next_segment) == 32:
+                        self.object_id = next_segment
+                    else:
+                        self.branch_name = unquote(next_segment).split("@")[0]
+                        if "@" in unquote(next_segment):
+                            self.commit_id = unquote(next_segment).split("@")[1]
+
+                else:
+                    raise SpeckleException(
+                        f"Cannot parse {url} into a stream wrapper class - invalid URL"
+                        " provided."
+                    )
 
         if use_fe2 is True and self.branch_name is not None:
-            if "," in self.branch_name:
-                raise SpeckleException("Multi-model urls are not supported yet")
-
-            if "@" in self.branch_name:
-                model_id = self.branch_name.split("@")[0]
-                self.commit_id = self.branch_name.split("@")[1]
-            else:
-                model_id = self.branch_name
-
+            self.model_id = self.branch_name
             # get branch name
             query = gql(
                 """
@@ -138,17 +153,18 @@ class StreamWrapper:
             """
             )
             self._client = self.get_client()
-            params = {"project_id": self.stream_id, "model_id": model_id}
+            params = {"project_id": self.stream_id, "model_id": self.model_id}
             project = self._client.httpclient.execute(query, params)
 
             try:
                 self.branch_name = project["project"]["model"]["name"]
             except KeyError as ke:
-                raise SpeckleException("Project model name is not found", ke)
+                raise SpeckleException("Project model name is not found", ke) from ke
 
         if not self.stream_id:
             raise SpeckleException(
-                f"Cannot parse {url} into a stream wrapper class - no stream id found."
+                f"Cannot parse {url} into a stream wrapper class - no {key_stream} ",
+                "id found.",
             )
 
     @property
@@ -163,14 +179,7 @@ class StreamWrapper:
         if self._account and self._account.token:
             return self._account
 
-        self._account = next(
-            (
-                a
-                for a in get_local_accounts()
-                if self.host == urlparse(a.serverInfo.url).netloc
-            ),
-            None,
-        )
+        self._account = next(iter(get_accounts_for_server(self.host)), None)
 
         if not self._account:
             self._account = get_account_from_token(token, self.server_url)
@@ -205,7 +214,11 @@ class StreamWrapper:
             self._client = SpeckleClient(host=self.host, use_ssl=self.use_ssl)
 
         if self._account.token is None and token is None:
-            warn(f"No local account found for server {self.host}", SpeckleWarning)
+            warn(
+                f"No local account found for server {self.host}",
+                SpeckleWarning,
+                stacklevel=2,
+            )
             return self._client
 
         if self._account.token:
@@ -229,3 +242,52 @@ class StreamWrapper:
         if not self._account or not self._account.token:
             self.get_account(token)
         return ServerTransport(self.stream_id, account=self._account)
+
+    def to_string(self) -> str:
+        """
+        Constructs a URL depending on the StreamWrapper type and FE version.
+        """
+        use_fe2 = False
+        key_streams = "/streams/"
+        key_branches = "/branches/"
+        if isinstance(self.branch_name, str):
+            value_branch = quote(self.branch_name)
+            if self.branch_name == "globals":
+                key_branches = "/"
+        key_commits = "/commits/"
+        if isinstance(self.commit_id, str) and self.branch_name == "globals":
+            key_commits = "/globals/"
+        key_objects = "/objects/"
+
+        if "/projects/" in self.stream_url:
+            use_fe2 = True
+            key_streams = "/projects/"
+            key_branches = "/models/"
+            value_branch = self.model_id
+            key_commits = "@"
+            key_objects = "/models/"
+
+        wrapper_type = self.type
+        if use_fe2 is False or (use_fe2 is True and not self.model_id):
+            base_url = f"{self.server_url}{key_streams}{self.stream_id}"
+        else:  # fe2 is True and model_id available
+            base_url = (
+                f"{self.server_url}{key_streams}"
+                f"{self.stream_id}{key_branches}{value_branch}"
+            )
+
+        if wrapper_type == "object":
+            return f"{base_url}{key_objects}{self.object_id}"
+        elif wrapper_type == "commit":
+            return f"{base_url}{key_commits}{self.commit_id}"
+        elif wrapper_type == "branch":
+            return (
+                f"{self.server_url}{key_streams}{self.stream_id}"
+                f"{key_branches}{value_branch}"
+            )
+        elif wrapper_type == "stream":
+            return f"{self.server_url}{key_streams}{self.stream_id}"
+        else:
+            raise SpeckleException(
+                f"Cannot parse StreamWrapper of type '{wrapper_type}'"
+            )

src/specklepy/core/helpers/speckle_path_provider.py

@@ -1,6 +1,7 @@
 """
 Provides uniform and consistent path helpers for `specklepy`
 """
+
 import os
 import sys
 from pathlib import Path
@@ -98,7 +99,7 @@ def user_application_data_path() -> Path:
     except Exception as ex:
         raise SpeckleException(
             message="Failed to initialize user application data path.", exception=ex
-        )
+        ) from ex
 
 
 def user_speckle_folder_path() -> Path:

src/specklepy/logging/metrics.py

@@ -28,7 +28,7 @@ CONNECTOR = "Connector Action"
 RECEIVE = "Receive"
 SEND = "Send"
 
-# not in use since 2.15  
+# not in use since 2.15
 ACCOUNTS = "Get Local Accounts"
 BRANCH = "Branch Action"
 CLIENT = "Speckle Client"
@@ -86,7 +86,8 @@ def track(
 
         METRICS_TRACKER.queue.put_nowait(event_params)
     except Exception as ex:
-        # wrapping this whole thing in a try except as we never want a failure here to annoy users!
+        # wrapping this whole thing in a try except as we never want a failure here
+        # to annoy users!
         LOG.debug(f"Error queueing metrics request: {str(ex)}")
 
 
@@ -106,7 +107,7 @@ class Singleton(type):
 
     def __call__(cls, *args, **kwargs):
         if cls not in cls._instances:
-            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
+            cls._instances[cls] = super().__call__(*args, **kwargs)
         return cls._instances[cls]
 
 
@@ -142,7 +143,7 @@ class MetricsTracker(metaclass=Singleton):
 
     def hash(self, value: str):
         inputList = value.lower().split("://")
-        input = inputList[len(inputList)-1].split("/")[0].split('?')[0]
+        input = inputList[len(inputList) - 1].split("/")[0].split("?")[0]
         return hashlib.md5(input.encode("utf-8")).hexdigest().upper()
 
     def _send_tracking_requests(self):

src/specklepy/objects/GIS/CRS.py

@@ -1,16 +0,0 @@
-from typing import Optional
-from specklepy.objects import Base
-
-
-class CRS(Base, speckle_type="Objects.GIS.CRS"):
-    """A Coordinate Reference System stored in wkt format"""
-
-    name: Optional[str] = None
-    authority_id: Optional[str] = None
-    wkt: Optional[str] = None
-    units_native: Optional[str] = None 
-    offset_x: Optional[float] = None
-    offset_y: Optional[float] = None
-    rotation: Optional[float] = None
-
-

src/specklepy/objects/GIS/__init__.py

@@ -1,22 +0,0 @@
-"""Builtin Speckle object kit."""
-
-from specklepy.objects.GIS.layers import (
-    VectorLayer,
-    RasterLayer,
-)
-
-from specklepy.objects.GIS.geometry import (
-    GisPolygonGeometry,
-    GisPolygonElement,
-    GisLineElement,
-    GisPointElement,
-    GisRasterElement,
-)
-
-from specklepy.objects.GIS.CRS import (
-    CRS,
-)
-
-__all__ = ["VectorLayer", "RasterLayer", 
-           "GisPolygonGeometry", "GisPolygonElement", "GisLineElement", "GisPointElement", "GisRasterElement", 
-           "CRS"]

src/specklepy/objects/GIS/geometry.py

@@ -1,53 +0,0 @@
-
-from typing import Optional, Union, List 
-from specklepy.objects.geometry import Point, Line, Polyline, Circle, Arc, Polycurve, Mesh 
-from specklepy.objects import Base
-from deprecated import deprecated
-
-class GisPolygonGeometry(Base, speckle_type="Objects.GIS.PolygonGeometry", detachable={"displayValue"}):
-    """GIS Polygon Geometry"""
-
-    boundary: Optional[Union[Polyline, Arc, Line, Circle, Polycurve]] = None
-    voids: Optional[List[Union[Polyline, Arc, Line, Circle, Polycurve]] ] = None
-    displayValue: Optional[List[Mesh]] = None
-
-class GisPolygonElement(Base, speckle_type="Objects.GIS.PolygonElement"):
-    """GIS Polygon element"""
-
-    geometry: Optional[List[GisPolygonGeometry]] = None
-    attributes: Optional[Base] = None
-
-class GisLineElement(Base, speckle_type="Objects.GIS.LineElement"):
-    """GIS Polyline element"""
-
-    geometry: Optional[List[Union[Polyline, Arc, Line, Circle, Polycurve]]] = None,
-    attributes: Optional[Base] = None,
-
-class GisPointElement(Base, speckle_type="Objects.GIS.PointElement"):
-    """GIS Point element"""
-
-    geometry: Optional[List[Point]] = None,
-    attributes: Optional[Base] = None,
-
-class GisRasterElement(Base, speckle_type="Objects.GIS.RasterElement", detachable={"displayValue"}):
-    """GIS Raster element"""
-
-    band_count: Optional[int] = None
-    band_names: Optional[List[str]] = None
-    x_origin: Optional[float] = None
-    y_origin: Optional[float] = None
-    x_size: Optional[int] = None
-    y_size: Optional[int] = None
-    x_resolution: Optional[float] = None
-    y_resolution: Optional[float] = None
-    noDataValue: Optional[List[float]] = None
-    displayValue: Optional[List[Mesh]] = None
-
-class GisTopography(GisRasterElement, speckle_type="Objects.GIS.GisTopography", detachable={"displayValue"}):
-    """GIS Raster element with 3d Topography representation"""
-
-class GisNonGeometryElement(Base, speckle_type="Objects.GIS.NonGeometryElement"):
-    """GIS Table feature"""
-
-    attributes: Optional[Base] = None
-

src/specklepy/objects/GIS/layers.py

@@ -1,138 +0,0 @@
-from typing import Any, Dict, List, Union, Optional
-from specklepy.objects.base import Base
-from specklepy.objects.other import Collection
-
-from specklepy.objects.GIS.CRS import CRS
-from deprecated import deprecated
-
-@deprecated(version="2.15", reason="Use VectorLayer or RasterLayer instead")
-class Layer(Base, detachable={"features"}):
-    """A GIS Layer"""
-    def __init__(
-        self,
-        name:str=None,
-        crs:CRS=None,
-        units: str = "m",
-        features: Optional[List[Base]] = None,
-        layerType: str = "None",
-        geomType: str = "None",
-        renderer: Optional[dict[str, Any]] = None,
-        **kwargs
-    ) -> None:
-        super().__init__(**kwargs)
-        self.name = name
-        self.crs = crs
-        self.units = units
-        self.type = layerType
-        self.features = features or []
-        self.geomType = geomType
-        self.renderer = renderer or {} 
-
-@deprecated(version="2.16", reason="Use VectorLayer or RasterLayer instead")
-class VectorLayer(
-    Collection, 
-    detachable={"elements"}, 
-    speckle_type="VectorLayer", 
-    serialize_ignore={"features"}):
-
-    """GIS Vector Layer"""
-    name: Optional[str]=None
-    crs: Optional[Union[CRS, Base]]=None
-    units: Optional[str] = None
-    elements: Optional[List[Base]] = None
-    attributes: Optional[Base] = None
-    geomType: Optional[str] = "None"
-    renderer: Optional[Dict[str, Any]] = None
-    collectionType = "VectorLayer"
-    
-    @property
-    @deprecated(version="2.14", reason="Use elements")
-    def features(self) -> Optional[List[Base]]:
-        return self.elements
-
-    @features.setter
-    def features(self, value: Optional[List[Base]]) -> None:
-        self.elements = value
-
-@deprecated(version="2.16", reason="Use VectorLayer or RasterLayer instead")
-class RasterLayer(
-    Collection, 
-    detachable={"elements"}, 
-    speckle_type="RasterLayer", 
-    serialize_ignore={"features"}):
-
-    """GIS Raster Layer"""
-
-    name: Optional[str] = None
-    crs: Optional[Union[CRS, Base]]=None
-    units: Optional[str] = None
-    rasterCrs: Optional[Union[CRS, Base]]=None
-    elements: Optional[List[Base]] = None
-    geomType: Optional[str] = "None"
-    renderer: Optional[Dict[str, Any]] = None
-    collectionType = "RasterLayer"
-
-    
-    @property
-    @deprecated(version="2.14", reason="Use elements")
-    def features(self) -> Optional[List[Base]]:
-        return self.elements
-
-    @features.setter
-    def features(self, value: Optional[List[Base]]) -> None:
-        self.elements = value
-
-
-class VectorLayer(
-    Collection, 
-    detachable={"elements"}, 
-    speckle_type="Objects.GIS.VectorLayer", 
-    serialize_ignore={"features"}):
-
-    """GIS Vector Layer"""
-
-    name: Optional[str]=None
-    crs: Optional[Union[CRS, Base]]=None
-    units: Optional[str] = None
-    elements: Optional[List[Base]] = None
-    attributes: Optional[Base] = None
-    geomType: Optional[str] = "None"
-    renderer: Optional[Dict[str, Any]] = None
-    collectionType = "VectorLayer"
-    
-    @property
-    @deprecated(version="2.14", reason="Use elements")
-    def features(self) -> Optional[List[Base]]:
-        return self.elements
-
-    @features.setter
-    def features(self, value: Optional[List[Base]]) -> None:
-        self.elements = value
-
-class RasterLayer(
-    Collection, 
-    detachable={"elements"}, 
-    speckle_type="Objects.GIS.RasterLayer", 
-    serialize_ignore={"features"}):
-
-    """GIS Raster Layer"""
-
-    name: Optional[str] = None
-    crs: Optional[Union[CRS, Base]]=None
-    units: Optional[str] = None
-    rasterCrs: Optional[Union[CRS, Base]]=None
-    elements: Optional[List[Base]] = None
-    geomType: Optional[str] = "None"
-    renderer: Optional[Dict[str, Any]] = None
-    collectionType = "RasterLayer"
-
-    
-    @property
-    @deprecated(version="2.14", reason="Use elements")
-    def features(self) -> Optional[List[Base]]:
-        return self.elements
-
-    @features.setter
-    def features(self, value: Optional[List[Base]]) -> None:
-        self.elements = value
-

src/specklepy/objects/__init__.py

@@ -1,6 +1,6 @@
-"""Builtin Speckle object kit."""
+from .data_objects import DataObject, QgisObject
 
-from specklepy.objects import encoding, geometry, other, primitive, structural, units
-from specklepy.objects.base import Base
-
-__all__ = ["Base", "encoding", "geometry", "other", "units", "structural", "primitive"]
+__all__ = [
+    "DataObject",
+    "QgisObject",
+]

src/specklepy/objects/base.py

@@ -1,4 +1,5 @@
 import contextlib
+from dataclasses import dataclass, field
 from enum import Enum
 from inspect import isclass
 from typing import (
@@ -18,8 +19,7 @@ from warnings import warn
 
 from stringcase import pascalcase
 
-from specklepy.logging.exceptions import SpeckleException, SpeckleInvalidUnitException
-from specklepy.objects.units import Units, get_units_from_string
+from specklepy.logging.exceptions import SpeckleException
 from specklepy.transports.memory import MemoryTransport
 
 PRIMITIVES = (int, float, str, bool)
@@ -65,7 +65,6 @@ REMOVE_FROM_DIR = {
     "_handle_object_count",
     "_type_check",
     "_type_registry",
-    "_units",
     "add_chunkable_attrs",
     "add_detachable_attrs",
     "get_children_count",
@@ -116,7 +115,7 @@ class _RegisteringBase:
     @classmethod
     def _determine_speckle_type(cls) -> str:
         """
-        This method brings the speckle_type construction in par with peckle-sharp/Core.
+        This method brings the speckle_type construction in par with Speckle-sharp/Core.
 
         The implementation differs, because in Core the basis of the speckle_type if
         type.FullName, which includes the dotnet namespace name too.
@@ -168,8 +167,11 @@ class _RegisteringBase:
         initialization. This is reused to register each subclassing type into a class
         level dictionary.
         """
+        # if not speckle_type:
+        #     raise Exception("no type")
         cls._speckle_type_override = speckle_type
         cls.speckle_type = cls._determine_speckle_type()
+        # cls.speckle_type = speckle_type
         if cls._full_name() in cls._type_registry:
             raise ValueError(
                 f"The speckle_type: {speckle_type} is already registered for type: "
@@ -188,7 +190,8 @@ class _RegisteringBase:
             cls._detachable = cls._detachable.union(detachable)
         if serialize_ignore:
             cls._serialize_ignore = cls._serialize_ignore.union(serialize_ignore)
-        super().__init_subclass__(**kwargs)
+        # we know, that the super here is object, that takes no args on init subclass
+        return super().__init_subclass__()
 
 
 # T = TypeVar("T")
@@ -221,7 +224,7 @@ def _validate_type(t: Optional[type], value: Any) -> Tuple[bool, Any]:
         if isinstance(t, ForwardRef):
             return True, value
 
-        origin = getattr(t, "__origin__")
+        origin = t.__origin__
         # below is what in nicer for >= py38
         # origin = get_origin(t)
 
@@ -286,7 +289,7 @@ def _validate_type(t: Optional[type], value: Any) -> Tuple[bool, Any]:
             if len(args) != len(value):
                 return False, value
             values = []
-            for t_item, v_item in zip(args, value):
+            for t_item, v_item in zip(args, value, strict=True):
                 item_valid, item_value = _validate_type(t_item, v_item)
                 if not item_valid:
                     return False, value
@@ -318,22 +321,17 @@ def _validate_type(t: Optional[type], value: Any) -> Tuple[bool, Any]:
     return False, value
 
 
-class Base(_RegisteringBase):
+@dataclass(kw_only=True)
+class Base(_RegisteringBase, speckle_type="Base"):
     id: Union[str, None] = None
-    totalChildrenCount: Union[int, None] = None
+    # totalChildrenCount: Union[int, None] = None
     applicationId: Union[str, None] = None
-    _units: Union[None, str] = None
-
-    def __init__(self, **kwargs) -> None:
-        super().__init__()
-        for k, v in kwargs.items():
-            self.__setattr__(k, v)
 
     def __repr__(self) -> str:
         return (
             f"{self.__class__.__name__}(id: {self.id}, "
             f"speckle_type: {self.speckle_type}, "
-            f"totalChildrenCount: {self.totalChildrenCount})"
+            # f"totalChildrenCount: {self.totalChildrenCount})"
         )
 
     def __str__(self) -> str:
@@ -374,7 +372,8 @@ class Base(_RegisteringBase):
         if name == "speckle_type":
             # not sure if we should raise an exception here??
             # raise SpeckleException(
-            #     "Cannot override the `speckle_type`. This is set manually by the class or on deserialisation"
+            #     "Cannot override the `speckle_type`."
+            #     "This is set manually by the class or on deserialisation"
             # )
             return
         # if value is not None:
@@ -402,7 +401,10 @@ class Base(_RegisteringBase):
         try:
             cls._attr_types = get_type_hints(cls)
         except Exception as e:
-            warn(f"Could not update forward refs for class {cls.__name__}: {e}")
+            warn(
+                f"Could not update forward refs for class {cls.__name__}: {e}",
+                stacklevel=2,
+            )
 
     @classmethod
     def validate_prop_name(cls, name: str) -> None:
@@ -461,21 +463,22 @@ class Base(_RegisteringBase):
         """
         self._detachable = self._detachable.union(names)
 
-    @property
-    def units(self) -> Union[str, None]:
-        return self._units
+    # @property
+    # def units(self) -> Union[str, None]:
+    #     return self._units
 
-    @units.setter
-    def units(self, value: Union[str, Units, None]):
-        """While this property accepts any string value, geometry expects units to be specific strings (see Units enum)"""
-        if isinstance(value, str) or value is None:
-            self._units = value
-        elif isinstance(value, Units):
-            self._units = value.value
-        else:
-            raise SpeckleInvalidUnitException(
-                f"Unknown type {type(value)} received for units"
-            )
+    # @units.setter
+    # def units(self, value: Union[str, Units, None]):
+    #     """While this property accepts any string value,
+    #        geometry expects units to be specific strings (see Units enum)"""
+    #     if isinstance(value, str) or value is None:
+    #         self._units = value
+    #     elif isinstance(value, Units):
+    #         self._units = value.value
+    #     else:
+    #         raise SpeckleInvalidUnitException(
+    #             f"Unknown type {type(value)} received for units"
+    #         )
 
     def get_member_names(self) -> List[str]:
         """Get all of the property names on this object, dynamic or not"""
@@ -567,9 +570,6 @@ class Base(_RegisteringBase):
 Base.update_forward_refs()
 
 
+@dataclass(kw_only=True)
 class DataChunk(Base, speckle_type="Speckle.Core.Models.DataChunk"):
-    data: Union[List[Any], None] = None
-
-    def __init__(self) -> None:
-        super().__init__()
-        self.data = []
+    data: List[Any] = field(default_factory=list)

src/specklepy/objects/data_objects.py

@@ -0,0 +1,81 @@
+from dataclasses import dataclass, field
+from typing import Dict, List
+from specklepy.objects.base import Base
+from specklepy.objects.interfaces import IDataObject, IGisObject, IHasUnits
+from specklepy.logging.exceptions import SpeckleException
+
+
+@dataclass(kw_only=True)
+class DataObject(
+    Base,
+    IDataObject,
+    speckle_type="Objects.Data.DataObject",
+    detachable={"displayValue"},
+):
+
+    name: str
+    properties: Dict[str, object]
+    displayValue: List[Base]
+    _name: str = field(repr=False, init=False)
+    _properties: Dict[str, object] = field(repr=False, init=False)
+    _displayValue: List[Base] = field(repr=False, init=False)
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def properties(self) -> Dict[str, object]:
+        return self._properties
+
+    @property
+    def displayValue(self) -> List[Base]:
+        return self._displayValue
+
+    @name.setter
+    def name(self, value: str):
+        if isinstance(value, str):
+            self._name = value
+        else:
+            raise SpeckleException(
+                f"'name' value should be string, received {type(value)}"
+            )
+
+    @properties.setter
+    def properties(self, value: dict):
+        if isinstance(value, dict):
+            self._properties = value
+        else:
+            raise SpeckleException(
+                f"'properties' value should be Dict, received {type(value)}"
+            )
+
+    @displayValue.setter
+    def displayValue(self, value: list):
+        if isinstance(value, list):
+            self._displayValue = value
+        else:
+            raise SpeckleException(
+                f"'displayValue' value should be List, received {type(value)}"
+            )
+
+
+@dataclass(kw_only=True)
+class QgisObject(
+    DataObject, IGisObject, IHasUnits, speckle_type="Objects.Data.QgisObject"
+):
+    type: str
+    _type: str = field(repr=False, init=False)
+
+    @property
+    def type(self) -> str:
+        return self._type
+
+    @type.setter
+    def type(self, value: str):
+        if isinstance(value, str):
+            self._type = value
+        else:
+            raise SpeckleException(
+                f"'type' value should be string, received {type(value)}"
+            )

src/specklepy/objects/encoding.py

@@ -1,131 +0,0 @@
-from enum import Enum
-from typing import Any, Callable, Dict, List, Optional, 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, data: Optional[list] = None) -> None:
-        self.data = data or []
-
-    @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(obj=obj)
-
-        return data_list
-
-    @staticmethod
-    def decode_data(
-        data: List[Any], decoder: Callable[[List[Any]], Base], **kwargs: Dict[str, Any]
-    ) -> List[Base]:
-        bases: List[Base] = []
-        if not data:
-            return bases
-        index = 0
-        while index < len(data):
-            item_length = int(data[index])
-            item_start = index + 1
-            item_end = item_start + item_length
-            item_data = data[item_start:item_end]
-            index = item_end
-            decoded_data = decoder(item_data, **kwargs)
-            bases.append(decoded_data)
-
-        return bases
-
-    def decode(self, decoder: Callable[[List[Any]], Any], **kwargs: Dict[str, Any]):
-        return self.decode_data(data=self.data, decoder=decoder, **kwargs)
-
-    def encode_object(self, obj: Base):
-        encoded = obj.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(data)
-        return crv_array.to_curve()
-
-    def to_curves(self) -> List[Base]:
-        return self.decode(decoder=self._curve_decoder)

src/specklepy/objects/geometry.py

@@ -1,946 +0,0 @@
-from enum import Enum
-from typing import Any, List, Optional
-
-from specklepy.objects.base import Base
-from specklepy.objects.encoding import CurveArray, CurveTypeEncoding, ObjectArray
-from specklepy.objects.primitive import Interval
-from specklepy.objects.units import get_encoding_from_units, get_units_from_encoding
-
-GEOMETRY = "Objects.Geometry."
-
-
-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:"
-            f" {self.id}, speckle_type: {self.speckle_type})"
-        )
-
-    @classmethod
-    def from_list(cls, args: List[float]) -> "Point":
-        """
-        Create a new Point from a list of three floats
-        representing the x, y, and z coordinates
-        """
-        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):
-        """Create a new Point from x, y, and z values"""
-        pt = Point()
-        pt.x, pt.y, pt.z = x, y, z
-        return pt
-
-
-class Pointcloud(
-    Base,
-    speckle_type=GEOMETRY + "Pointcloud",
-    chunkable={"points": 31250, "colors": 62500, "sizes": 62500},
-):
-    points: Optional[List[float]] = None
-    colors: Optional[List[int]] = None
-    sizes: Optional[List[float]] = None
-    bbox: Optional["Box"] = None
-
-
-class Vector(Base, speckle_type=GEOMETRY + "Vector"):
-    x: float = 0.0
-    y: float = 0.0
-    z: float = 0.0
-    applicationId: Optional[str] = None
-
-    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]) -> "Vector":
-        """
-        Create from a list of three floats representing the x, y, and z coordinates.
-        """
-        return cls(x=args[0], y=args[1], z=args[2])
-
-    def to_list(self) -> List[float]:
-        return [self.x, self.y, self.z]
-
-    @classmethod
-    def from_coords(cls, x: float = 0.0, y: float = 0.0, z: float = 0.0) -> "Vector":
-        """Create a new Point from x, y, and z values"""
-        v = Vector()
-        v.x, v.y, v.z = x, y, z
-        return v
-
-
-class ControlPoint(Point, speckle_type=GEOMETRY + "ControlPoint"):
-    weight: Optional[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[:3]),
-            normal=Vector.from_list(args[3:6]),
-            xdir=Vector.from_list(args[6:9]),
-            ydir=Vector.from_list(args[9:12]),
-            units=get_units_from_encoding(args[-1]),
-        )
-
-    def to_list(self) -> List[Any]:
-        return [
-            *self.origin.to_list(),
-            *self.normal.to_list(),
-            *self.xdir.to_list(),
-            *self.ydir.to_list(),
-            get_encoding_from_units(self._units),
-        ]
-
-
-class Box(Base, speckle_type=GEOMETRY + "Box"):
-    basePlane: Plane = Plane()
-    xSize: Interval = Interval()
-    ySize: Interval = Interval()
-    zSize: Interval = Interval()
-    area: Optional[float] = None
-    volume: Optional[float] = None
-
-
-class Line(Base, speckle_type=GEOMETRY + "Line"):
-    start: Point = Point()
-    end: Optional[Point] = None
-    domain: Optional[Interval] = None
-    bbox: Optional[Box] = None
-    length: Optional[float] = None
-
-    @classmethod
-    def from_list(cls, args: List[Any]) -> "Line":
-        return cls(
-            start=Point.from_list(args[1:4]),
-            end=Point.from_list(args[4:7]),
-            domain=Interval.from_list(args[7:10]),
-            units=get_units_from_encoding(args[-1]),
-        )
-
-    def to_list(self) -> List[Any]:
-        domain = self.domain.to_list() if self.domain else [0, 1]
-        return [
-            CurveTypeEncoding.Line.value,
-            *self.start.to_list(),
-            *self.end.to_list(),
-            *domain,
-            get_encoding_from_units(self._units),
-        ]
-
-
-class Arc(Base, speckle_type=GEOMETRY + "Arc"):
-    radius: Optional[float] = None
-    startAngle: Optional[float] = None
-    endAngle: Optional[float] = None
-    angleRadians: Optional[float] = None
-    plane: Optional[Plane] = None
-    domain: Optional[Interval] = None
-    startPoint: Optional[Point] = None
-    midPoint: Optional[Point] = None
-    endPoint: Optional[Point] = None
-    bbox: Optional[Box] = None
-    area: Optional[float] = None
-    length: Optional[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]),
-            startPoint=Point.from_list(args[20:23]),
-            midPoint=Point.from_list(args[23:26]),
-            endPoint=Point.from_list(args[26:29]),
-            units=get_units_from_encoding(args[-1]),
-        )
-
-    def to_list(self) -> List[Any]:
-        return [
-            CurveTypeEncoding.Arc.value,
-            self.radius,
-            self.startAngle,
-            self.endAngle,
-            self.angleRadians,
-            *self.domain.to_list(),
-            *self.plane.to_list(),
-            *self.startPoint.to_list(),
-            *self.midPoint.to_list(),
-            *self.endPoint.to_list(),
-            get_encoding_from_units(self._units),
-        ]
-
-
-class Circle(Base, speckle_type=GEOMETRY + "Circle"):
-    radius: Optional[float] = None
-    plane: Optional[Plane] = None
-    domain: Optional[Interval] = None
-    bbox: Optional[Box] = None
-    area: Optional[float] = None
-    length: Optional[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]:
-        return [
-            CurveTypeEncoding.Circle.value,
-            self.radius,
-            *self.domain.to_list(),
-            *self.plane.to_list(),
-            get_encoding_from_units(self._units),
-        ]
-
-
-class Ellipse(Base, speckle_type=GEOMETRY + "Ellipse"):
-    firstRadius: Optional[float] = None
-    secondRadius: Optional[float] = None
-    plane: Optional[Plane] = None
-    domain: Optional[Interval] = None
-    trimDomain: Optional[Interval] = None
-    bbox: Optional[Box] = None
-    area: Optional[float] = None
-    length: Optional[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]:
-        return [
-            CurveTypeEncoding.Ellipse.value,
-            self.firstRadius,
-            self.secondRadius,
-            *self.domain.to_list(),
-            *self.plane.to_list(),
-            get_encoding_from_units(self._units),
-        ]
-
-
-class Polyline(Base, speckle_type=GEOMETRY + "Polyline", chunkable={"value": 20000}):
-    value: Optional[List[float]] = None
-    closed: Optional[bool] = None
-    domain: Optional[Interval] = None
-    bbox: Optional[Box] = None
-    area: Optional[float] = None
-    length: Optional[float] = None
-
-    @classmethod
-    def from_points(cls, points: List[Point]):
-        """Create a new Polyline from a list of Points"""
-        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]:
-        return [
-            CurveTypeEncoding.Polyline.value,
-            int(self.closed),
-            *self.domain.to_list(),
-            len(self.value),
-            *self.value,
-            get_encoding_from_units(self._units),
-        ]
-
-    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 SpiralType(Enum):
-    Biquadratic = (0,)
-    BiquadraticParabola = (1,)
-    Bloss = (2,)
-    Clothoid = (3,)
-    Cosine = (4,)
-    Cubic = (5,)
-    CubicParabola = (6,)
-    Radioid = (7,)
-    Sinusoid = (8,)
-    Unknown = 9
-
-
-class Spiral(Base, speckle_type=GEOMETRY + "Spiral", detachable={"displayValue"}):
-    startPoint: Optional[Point] = None
-    endPoint: Optional[Point]
-    plane: Optional[Plane]
-    turns: Optional[float]
-    pitchAxis: Optional[Vector] = Vector()
-    pitch: float = 0
-    spiralType: Optional[SpiralType] = None
-    displayValue: Optional[Polyline] = None
-    bbox: Optional[Box] = None
-    length: Optional[float] = None
-    domain: Optional[Interval] = None
-
-
-class Curve(
-    Base,
-    speckle_type=GEOMETRY + "Curve",
-    chunkable={"points": 20000, "weights": 20000, "knots": 20000},
-):
-    degree: Optional[int] = None
-    periodic: Optional[bool] = None
-    rational: Optional[bool] = None
-    points: Optional[List[float]] = None
-    weights: Optional[List[float]] = None
-    knots: Optional[List[float]] = None
-    domain: Optional[Interval] = None
-    displayValue: Optional[Polyline] = None
-    closed: Optional[bool] = None
-    bbox: Optional[Box] = None
-    area: Optional[float] = None
-    length: Optional[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 = int(args[7])
-        weights_count = int(args[8])
-        knots_count = int(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=int(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]:
-        return [
-            CurveTypeEncoding.Curve.value,
-            self.degree,
-            int(self.periodic),
-            int(self.rational),
-            int(self.closed),
-            *self.domain.to_list(),
-            len(self.points),
-            len(self.weights),
-            len(self.knots),
-            *self.points,
-            *self.weights,
-            *self.knots,
-            get_encoding_from_units(self._units),
-        ]
-
-
-class Polycurve(Base, speckle_type=GEOMETRY + "Polycurve"):
-    segments: Optional[List[Base]] = None
-    domain: Optional[Interval] = None
-    closed: Optional[bool] = None
-    bbox: Optional[Box] = None
-    area: Optional[float] = None
-    length: Optional[float] = None
-
-    @classmethod
-    def from_list(cls, args: List[Any]) -> "Polycurve":
-        curve_arrays = CurveArray(args[5:-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]:
-        curve_array = CurveArray.from_curves(self.segments).data
-        return [
-            CurveTypeEncoding.Polycurve.value,
-            int(self.closed),
-            *self.domain.to_list(),
-            len(curve_array),
-            *curve_array,
-            get_encoding_from_units(self._units),
-        ]
-
-
-class Extrusion(Base, speckle_type=GEOMETRY + "Extrusion"):
-    capped: Optional[bool] = None
-    profile: Optional[Base] = None
-    pathStart: Optional[Point] = None
-    pathEnd: Optional[Point] = None
-    pathCurve: Optional[Base] = None
-    pathTangent: Optional[Base] = None
-    profiles: Optional[List[Base]] = None
-    length: Optional[float] = None
-    area: Optional[float] = None
-    volume: Optional[float] = None
-    bbox: Optional[Box] = None
-
-
-class Mesh(
-    Base,
-    speckle_type=GEOMETRY + "Mesh",
-    chunkable={
-        "vertices": 2000,
-        "faces": 2000,
-        "colors": 2000,
-        "textureCoordinates": 2000,
-    },
-):
-    vertices: Optional[List[float]] = None
-    faces: Optional[List[int]] = None
-    colors: Optional[List[int]] = None
-    textureCoordinates: Optional[List[float]] = None
-    bbox: Optional[Box] = None
-    area: Optional[float] = None
-    volume: Optional[float] = None
-
-    @classmethod
-    def create(
-        cls,
-        vertices: List[float],
-        faces: List[int],
-        colors: Optional[List[int]] = None,
-        texture_coordinates: Optional[List[float]] = None,
-    ) -> "Mesh":
-        """
-        Create a new Mesh from lists representing its vertices, faces,
-        colors (optional), and texture coordinates (optional).
-
-        This will initialise empty lists for colors and texture coordinates
-        if you do not provide any.
-        """
-        return cls(
-            vertices=vertices,
-            faces=faces,
-            colors=colors or [],
-            textureCoordinates=texture_coordinates or [],
-        )
-
-
-class Surface(Base, speckle_type=GEOMETRY + "Surface"):
-    degreeU: Optional[int] = None
-    degreeV: Optional[int] = None
-    rational: Optional[bool] = None
-    area: Optional[float] = None
-    pointData: Optional[List[float]] = None
-    countU: Optional[int] = None
-    countV: Optional[int] = None
-    bbox: Optional[Box] = None
-    closedU: Optional[bool] = None
-    closedV: Optional[bool] = None
-    domainU: Optional[Interval] = None
-    domainV: Optional[Interval] = None
-    knotsU: Optional[List[float]] = None
-    knotsV: Optional[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]:
-        return [
-            self.degreeU,
-            self.degreeV,
-            self.countU,
-            self.countV,
-            int(self.rational),
-            int(self.closedU),
-            int(self.closedV),
-            *self.domainU.to_list(),
-            *self.domainV.to_list(),
-            len(self.pointData),
-            len(self.knotsU),
-            len(self.knotsV),
-            *self.pointData,
-            *self.knotsU,
-            *self.knotsV,
-            get_encoding_from_units(self._units),
-        ]
-
-
-class BrepFace(Base, speckle_type=GEOMETRY + "BrepFace"):
-    _Brep: Optional["Brep"] = None
-    SurfaceIndex: Optional[int] = None
-    OuterLoopIndex: Optional[int] = None
-    OrientationReversed: Optional[bool] = None
-    LoopIndices: Optional[List[int]] = None
-
-    @property
-    def _outer_loop(self):
-        return self._Brep.Loops[self.OuterLoopIndex]  # pylint: disable=no-member
-
-    @property
-    def _surface(self):
-        return self._Brep.Surfaces[self.SurfaceIndex]  # pylint: disable=no-member
-
-    @property
-    def _loops(self):
-        if self.LoopIndices:
-            # pylint: disable=not-an-iterable, no-member
-            return [self._Brep.Loops[i] for i in self.LoopIndices]
-
-    @classmethod
-    def from_list(cls, args: List[Any], brep: "Brep" = None) -> "BrepFace":
-        return cls(
-            _Brep=brep,
-            SurfaceIndex=args[0],
-            OuterLoopIndex=args[1],
-            OrientationReversed=bool(args[2]),
-            LoopIndices=args[3:],
-        )
-
-    def to_list(self) -> List[Any]:
-        return [
-            self.SurfaceIndex,
-            self.OuterLoopIndex,
-            int(self.OrientationReversed),
-            *self.LoopIndices,
-        ]
-
-
-class BrepEdge(Base, speckle_type=GEOMETRY + "BrepEdge"):
-    _Brep: Optional["Brep"] = None
-    Curve3dIndex: Optional[int] = None
-    TrimIndices: Optional[List[int]] = None
-    StartIndex: Optional[int] = None
-    EndIndex: Optional[int] = None
-    ProxyCurveIsReversed: Optional[bool] = None
-    Domain: Optional[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:
-            # pylint: disable=not-an-iterable
-            return [self._Brep.Trims[i] for i in self.TrimIndices]
-
-    @property
-    def _curve(self):
-        return self._Brep.Curve3D[self.Curve3dIndex]
-
-    @classmethod
-    def from_list(cls, args: List[Any], brep: "Brep" = None) -> "BrepEdge":
-        domain_start = args[4]
-        domain_end = args[5]
-        domain = (
-            Interval(start=domain_start, end=domain_end)
-            if None not in (domain_start, domain_end)
-            else None
-        )
-        return cls(
-            _Brep=brep,
-            Curve3dIndex=int(args[0]),
-            TrimIndices=[int(t) for t in args[6:]],
-            StartIndex=int(args[1]),
-            EndIndex=int(args[2]),
-            ProxyCurveIsReversed=bool(args[3]),
-            Domain=domain,
-        )
-
-    def to_list(self) -> List[Any]:
-        return [
-            self.Curve3dIndex,
-            self.StartIndex,
-            self.EndIndex,
-            int(self.ProxyCurveIsReversed),
-            self.Domain.start,
-            self.Domain.end,
-            *self.TrimIndices,
-        ]
-
-
-class BrepLoopType(int, Enum):
-    Unknown = 0
-    Outer = 1
-    Inner = 2
-    Slit = 3
-    CurveOnSurface = 4
-    PointOnSurface = 5
-
-
-class BrepLoop(Base, speckle_type=GEOMETRY + "BrepLoop"):
-    _Brep: Optional["Brep"] = None
-    FaceIndex: Optional[Optional[int]] = None
-    TrimIndices: Optional[List[int]] = None
-    Type: Optional[BrepLoopType] = None
-
-    @property
-    def _face(self):
-        return self._Brep.Faces[self.FaceIndex]
-
-    @property
-    def _trims(self):
-        if self.TrimIndices:
-            # pylint: disable=not-an-iterable
-            return [self._Brep.Trims[i] for i in self.TrimIndices]
-
-    @classmethod
-    def from_list(cls, args: List[any], brep: "Brep" = None):
-        return cls(
-            _Brep=brep,
-            FaceIndex=args[0],
-            Type=BrepLoopType(args[1]),
-            TrimIndices=args[2:],
-        )
-
-    def to_list(self) -> List[int]:
-        return [
-            self.FaceIndex,
-            self.Type.value,
-            *self.TrimIndices,
-        ]
-
-
-class BrepTrimType(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: Optional["Brep"] = None
-    EdgeIndex: Optional[int] = None
-    StartIndex: Optional[int] = None
-    EndIndex: Optional[int] = None
-    FaceIndex: Optional[int] = None
-    LoopIndex: Optional[int] = None
-    CurveIndex: Optional[int] = None
-    IsoStatus: Optional[int] = None
-    TrimType: Optional[BrepTrimType] = None
-    IsReversed: Optional[bool] = None
-    Domain: Optional[Interval] = None
-
-    @property
-    def _face(self):
-        if self._Brep:
-            return self._Brep.Faces[self.FaceIndex]  # pylint: disable=no-member
-
-    @property
-    def _loop(self):
-        if self._Brep:
-            return self._Brep.Loops[self.LoopIndex]  # pylint: disable=no-member
-
-    @property
-    def _edge(self):
-        if self._Brep:
-            # pylint: disable=no-member
-            return self._Brep.Edges[self.EdgeIndex] if self.EdgeIndex != -1 else None
-
-    @property
-    def _curve_2d(self):
-        if self._Brep:
-            return self._Brep.Curve2D[self.CurveIndex]  # pylint: disable=no-member
-
-    @classmethod
-    def from_list(cls, args: List[Any], brep: "Brep" = None) -> "BrepTrim":
-        return cls(
-            _Brep=brep,
-            EdgeIndex=args[0],
-            StartIndex=args[1],
-            EndIndex=args[2],
-            FaceIndex=args[3],
-            LoopIndex=args[4],
-            CurveIndex=args[5],
-            IsoStatus=args[6],
-            TrimType=BrepTrimType(args[7]),
-            IsReversed=bool(args[8]),
-        )
-
-    def to_list(self) -> List[Any]:
-        return [
-            self.EdgeIndex,
-            self.StartIndex,
-            self.EndIndex,
-            self.FaceIndex,
-            self.LoopIndex,
-            self.CurveIndex,
-            self.IsoStatus,
-            self.TrimType.value,
-            int(self.IsReversed),
-        ]
-
-
-class Brep(
-    Base,
-    speckle_type=GEOMETRY + "Brep",
-    chunkable={
-        "SurfacesValue": 31250,
-        "Curve3DValues": 31250,
-        "Curve2DValues": 31250,
-        "VerticesValue": 31250,
-        "EdgesValue": 62500,
-        "LoopsValue": 62500,
-        "FacesValue": 62500,
-        "TrimsValue": 62500,
-    },
-    detachable={"displayValue"},
-    serialize_ignore={
-        "Surfaces",
-        "Curve3D",
-        "Curve2D",
-        "Vertices",
-        "Trims",
-        "Edges",
-        "Loops",
-        "Faces",
-    },
-):
-    provenance: Optional[str] = None
-    bbox: Optional[Box] = None
-    area: Optional[float] = None
-    volume: Optional[float] = None
-    _displayValue: Optional[List[Mesh]] = None
-    Surfaces: Optional[List[Surface]] = None
-    Curve3D: Optional[List[Base]] = None
-    Curve2D: Optional[List[Base]] = None
-    Vertices: Optional[List[Point]] = None
-    Edges: Optional[List[BrepEdge]] = None
-    Loops: Optional[List[BrepLoop]] = None
-    Faces: Optional[List[BrepFace]] = None
-    Trims: Optional[List[BrepTrim]] = None
-    IsClosed: Optional[bool] = None
-    Orientation: Optional[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  # pylint: disable=protected-access
-        return children
-
-    # set as prop for now for backwards compatibility
-    @property
-    def displayValue(self) -> List[Mesh]:
-        return self._displayValue
-
-    @displayValue.setter
-    def displayValue(self, value):
-        if isinstance(value, Mesh):
-            self._displayValue = [value]
-        elif isinstance(value, list):
-            self._displayValue = value
-
-    @property
-    def EdgesValue(self) -> List[BrepEdge]:
-        return None if self.Edges is None else ObjectArray.from_objects(self.Edges).data
-
-    @EdgesValue.setter
-    def EdgesValue(self, value: List[float]):
-        if not value:
-            return
-
-        self.Edges = ObjectArray.decode_data(value, BrepEdge.from_list, brep=self)
-
-    @property
-    def LoopsValue(self) -> List[BrepLoop]:
-        return None if self.Loops is None else ObjectArray.from_objects(self.Loops).data
-
-    @LoopsValue.setter
-    def LoopsValue(self, value: List[int]):
-        if not value:
-            return
-
-        self.Loops = ObjectArray.decode_data(value, BrepLoop.from_list, brep=self)
-
-    @property
-    def FacesValue(self) -> List[int]:
-        return None if self.Faces is None else ObjectArray.from_objects(self.Faces).data
-
-    @FacesValue.setter
-    def FacesValue(self, value: List[int]):
-        if not value:
-            return
-
-        self.Faces = ObjectArray.decode_data(value, BrepFace.from_list, brep=self)
-
-    @property
-    def SurfacesValue(self) -> List[float]:
-        return (
-            None
-            if self.Surfaces is None
-            else ObjectArray.from_objects(self.Surfaces).data
-        )
-
-    @SurfacesValue.setter
-    def SurfacesValue(self, value: List[float]):
-        if not value:
-            return
-
-        self.Surfaces = ObjectArray.decode_data(value, Surface.from_list)
-
-    @property
-    def Curve3DValues(self) -> List[float]:
-        return (
-            None if self.Curve3D is None else CurveArray.from_curves(self.Curve3D).data
-        )
-
-    @Curve3DValues.setter
-    def Curve3DValues(self, value: List[float]):
-        crv_array = CurveArray(value)
-        self.Curve3D = crv_array.to_curves()
-
-    @property
-    def Curve2DValues(self) -> List[Base]:
-        return (
-            None if self.Curve2D is None else CurveArray.from_curves(self.Curve2D).data
-        )
-
-    @Curve2DValues.setter
-    def Curve2DValues(self, value: List[float]):
-        crv_array = CurveArray(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
-
-    # TODO: can this be consistent with loops, edges, faces, curves, etc and prepend with the chunk list? needs to happen in sharp first
-    @property
-    def TrimsValue(self) -> List[float]:
-        # return None if self.Trims is None else ObjectArray.from_objects(self.Trims).data
-        if not self.Trims:
-            return
-        value = []
-        for trim in self.Trims:
-            value.extend(trim.to_list())
-        return value
-
-    @TrimsValue.setter
-    def TrimsValue(self, value: List[float]):
-        if not value:
-            return
-
-        # self.Trims = ObjectArray.decode_data(value, BrepTrim.from_list, brep=self)
-        self.Trims = [
-            BrepTrim.from_list(value[i : i + 9], self) for i in range(0, len(value), 9)
-        ]
-
-
-BrepEdge.update_forward_refs()
-BrepLoop.update_forward_refs()
-BrepTrim.update_forward_refs()
-BrepFace.update_forward_refs()

src/specklepy/objects/geometry/__init__.py

@@ -0,0 +1,18 @@
+from specklepy.objects.geometry.arc import Arc
+from specklepy.objects.geometry.line import Line
+from specklepy.objects.geometry.mesh import Mesh
+from specklepy.objects.geometry.plane import Plane
+from specklepy.objects.geometry.point import Point
+from specklepy.objects.geometry.polyline import Polyline
+from specklepy.objects.geometry.vector import Vector
+
+# re-export them at the geometry package level
+__all__ = [
+    "Arc",
+    "Line",
+    "Mesh",
+    "Plane",
+    "Point",
+    "Polyline",
+    "Vector"
+]

src/specklepy/objects/geometry/arc.py

@@ -0,0 +1,36 @@
+import math
+from dataclasses import dataclass
+
+from specklepy.objects.base import Base
+from specklepy.objects.geometry.plane import Plane
+from specklepy.objects.geometry.point import Point
+from specklepy.objects.interfaces import ICurve, IHasUnits
+
+
+@dataclass(kw_only=True)
+class Arc(Base, IHasUnits, ICurve, speckle_type="Objects.Geometry.Arc"):
+    plane: Plane
+    startPoint: Point
+    midPoint: Point
+    endPoint: Point
+
+    @property
+    def radius(self) -> float:
+        return self.startPoint.distance_to(self.plane.origin)
+
+    @property
+    def length(self) -> float:
+        start_to_mid = self.startPoint.distance_to(self.midPoint)
+        mid_to_end = self.midPoint.distance_to(self.endPoint)
+        r = self.radius
+        angle = (2 * math.asin(start_to_mid / (2 * r))) + \
+            (2 * math.asin(mid_to_end / (2 * r)))
+        return r * angle
+
+    @property
+    def measure(self) -> float:
+        start_to_mid = self.startPoint.distance_to(self.midPoint)
+        mid_to_end = self.midPoint.distance_to(self.endPoint)
+        r = self.radius
+        return (2 * math.asin(start_to_mid / (2 * r))) + \
+            (2 * math.asin(mid_to_end / (2 * r)))

src/specklepy/objects/geometry/line.py

@@ -0,0 +1,20 @@
+from dataclasses import dataclass
+
+from specklepy.objects.base import Base
+from specklepy.objects.geometry.point import Point
+from specklepy.objects.interfaces import ICurve, IHasUnits
+
+
+@dataclass(kw_only=True)
+class Line(
+    Base,
+    IHasUnits,
+    ICurve,
+    speckle_type="Objects.Geometry.Line"
+):
+    start: Point
+    end: Point
+
+    @property
+    def length(self) -> float:
+        return self.start.distance_to(self.end)

src/specklepy/objects/geometry/mesh.py

@@ -0,0 +1,211 @@
+from dataclasses import dataclass, field
+from typing import List, Tuple
+
+from specklepy.objects.base import Base
+from specklepy.objects.geometry.point import Point
+from specklepy.objects.interfaces import IHasArea, IHasUnits, IHasVolume
+
+
+@dataclass(kw_only=True)
+class Mesh(
+    Base,
+    IHasArea,
+    IHasVolume,
+    IHasUnits,
+    speckle_type="Objects.Geometry.Mesh",
+    detachable={"vertices", "faces", "colors", "textureCoordinates"},
+    chunkable={
+        "vertices": 31250,
+        "faces": 62500,
+        "colors": 62500,
+        "textureCoordinates": 31250,
+    },
+    serialize_ignore={"vertices_count", "texture_coordinates_count"},
+):
+    """
+    a 3D mesh consisting of vertices and faces with optional colors and texture coordinates
+    """
+    vertices: List[float]
+    faces: List[int]
+    colors: List[int] = field(default_factory=list)
+    textureCoordinates: List[float] = field(default_factory=list)
+
+    def __repr__(self) -> str:
+        return (
+            f"{self.__class__.__name__}("
+            f"vertices: {self.vertices_count}, "
+            f"faces: {self.faces_count}, "
+            f"units: {self.units}, "
+            f"has_colors: {len(self.colors) > 0}, "
+            f"has_texture_coords: {len(self.textureCoordinates) > 0})"
+        )
+
+    @property
+    def vertices_count(self) -> int:
+        """
+        get the number of vertices in the mesh
+        """
+
+        if len(self.vertices) % 3 != 0:
+            raise ValueError(
+                f"Invalid vertices list: length ({len(
+                    self.vertices)}) must be a multiple of 3"
+            )
+        return len(self.vertices) // 3
+
+    @property
+    def texture_coordinates_count(self) -> int:
+        """
+        get the number of texture coordinates in the mesh
+        """
+        return len(self.textureCoordinates) // 2
+
+    @property
+    def area(self) -> float:
+        return self.__dict__.get('_area', 0.0)
+
+    @area.setter
+    def area(self, value: float) -> None:
+        self.__dict__['_area'] = value
+
+    @property
+    def volume(self) -> float:
+        return self.__dict__.get('_volume', 0.0)
+
+    @volume.setter
+    def volume(self, value: float) -> None:
+        self.__dict__['_volume'] = value
+
+    def calculate_area(self) -> float:
+        """
+        calculate total surface area of the mesh
+        """
+        total_area = 0.0
+        face_index = 0
+        i = 0
+
+        while i < len(self.faces):
+            vertex_count = self.faces[i]
+            if vertex_count >= 3:
+                face_vertices = self.get_face_vertices(face_index)
+                for j in range(1, vertex_count - 1):
+                    v0 = face_vertices[0]
+                    v1 = face_vertices[j]
+                    v2 = face_vertices[j + 1]
+                    a = [v1.x - v0.x, v1.y - v0.y, v1.z - v0.z]
+                    b = [v2.x - v0.x, v2.y - v0.y, v2.z - v0.z]
+                    cx = a[1] * b[2] - a[2] * b[1]
+                    cy = a[2] * b[0] - a[0] * b[2]
+                    cz = a[0] * b[1] - a[1] * b[0]
+                    area = 0.5 * (cx * cx + cy * cy + cz * cz) ** 0.5
+                    total_area += area
+            i += vertex_count + 1
+            face_index += 1
+
+        return total_area
+
+    def calculate_volume(self) -> float:
+        """
+        calculate volume of the mesh if it is closed
+        """
+        if not self.is_closed():
+            return 0.0
+
+        total_volume = 0.0
+        face_index = 0
+        i = 0
+        while i < len(self.faces):
+            vertex_count = self.faces[i]
+            if vertex_count >= 3:
+                face_vertices = self.get_face_vertices(face_index)
+                v0 = face_vertices[0]
+                for j in range(1, vertex_count - 1):
+                    v1 = face_vertices[j]
+                    v2 = face_vertices[j + 1]
+                    a = [v0.x, v0.y, v0.z]
+                    b = [v1.x - v0.x, v1.y - v0.y, v1.z - v0.z]
+                    c = [v2.x - v0.x, v2.y - v0.y, v2.z - v0.z]
+                    cx = b[1] * c[2] - b[2] * c[1]
+                    cy = b[2] * c[0] - b[0] * c[2]
+                    cz = b[0] * c[1] - b[1] * c[0]
+                    v = (a[0] * cx + a[1] * cy + a[2] * cz) / 6.0
+                    total_volume += v
+            i += vertex_count + 1
+            face_index += 1
+
+        return abs(total_volume)
+
+    def get_point(self, index: int) -> Point:
+        """
+        get vertex at index as a Point object
+        """
+        if index < 0 or index >= self.vertices_count:
+            raise IndexError(f"Vertex index {index} out of range")
+
+        index *= 3
+        return Point(
+            x=self.vertices[index],
+            y=self.vertices[index + 1],
+            z=self.vertices[index + 2],
+            units=self.units,
+        )
+
+    def get_points(self) -> List[Point]:
+        """
+        get all vertices as Point objects
+        """
+        return [self.get_point(i) for i in range(self.vertices_count)]
+
+    def get_texture_coordinate(self, index: int) -> Tuple[float, float]:
+        """
+        get texture coordinate at index
+        """
+        if index < 0 or index >= self.texture_coordinates_count:
+            raise IndexError(f"Texture coordinate index {index} out of range")
+
+        index *= 2
+        return (self.textureCoordinates[index], self.textureCoordinates[index + 1])
+
+    def get_face_vertices(self, face_index: int) -> List[Point]:
+        """
+        get the vertices of a specific face
+        """
+        i = 0
+        current_face = 0
+
+        while i < len(self.faces):
+            if current_face == face_index:
+                vertex_count = self.faces[i]
+                vertices = []
+                for j in range(vertex_count):
+                    vertex_index = self.faces[i + j + 1]
+                    if vertex_index >= self.vertices_count:
+                        raise IndexError(
+                            f"Vertex index {vertex_index} out of range")
+                    vertices.append(self.get_point(vertex_index))
+                return vertices
+
+            vertex_count = self.faces[i]
+            i += vertex_count + 1
+            current_face += 1
+
+        raise IndexError(f"Face index {face_index} out of range")
+
+    def is_closed(self) -> bool:
+        """
+        check if the mesh is closed (verifying each edge appears twice)
+        """
+        edge_counts = {}
+
+        i = 0
+        while i < len(self.faces):
+            vertex_count = self.faces[i]
+            for j in range(vertex_count):
+                v1 = self.faces[i + 1 + j]
+                v2 = self.faces[i + 1 + ((j + 1) % vertex_count)]
+                edge = tuple(sorted([v1, v2]))
+                edge_counts[edge] = edge_counts.get(edge, 0) + 1
+
+            i += vertex_count + 1
+
+        return all(count == 2 for count in edge_counts.values())

src/specklepy/objects/geometry/plane.py

@@ -0,0 +1,28 @@
+from dataclasses import dataclass
+
+from specklepy.objects.base import Base
+from specklepy.objects.geometry.point import Point
+from specklepy.objects.geometry.vector import Vector
+from specklepy.objects.interfaces import IHasUnits
+
+
+@dataclass(kw_only=True)
+class Plane(Base, IHasUnits, speckle_type="Objects.Geometry.Plane"):
+    """
+    a plane consisting of an origin Point, and 3 Vectors as its X, Y and Z axis.
+    """
+
+    origin: Point
+    normal: Vector
+    xdir: Vector
+    ydir: Vector
+
+    def __repr__(self) -> str:
+        return (
+            f"{self.__class__.__name__}("
+            f"origin: {self.origin}, "
+            f"normal: {self.normal}, "
+            f"xdir: {self.xdir}, "
+            f"ydir: {self.ydir}, "
+            f"units: {self.units})"
+        )

src/specklepy/objects/geometry/point.py

@@ -0,0 +1,33 @@
+from dataclasses import dataclass
+
+from specklepy.objects.base import Base
+from specklepy.objects.interfaces import IHasUnits
+
+
+@dataclass(kw_only=True)
+class Point(Base, IHasUnits, speckle_type="Objects.Geometry.Point"):
+    """
+    a 3-dimensional point
+    """
+
+    x: float
+    y: float
+    z: float
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(x: {self.x}, y: {self.y}, z: {self.z}, units: {self.units})"
+
+    def distance_to(self, other: "Point") -> float:
+        """
+        calculates the distance between this point and another given point.
+        """
+        if not isinstance(other, Point):
+            raise TypeError(f"Expected Point object, got {type(other)}")
+
+        # we assume that host application units are the same for both points
+        # unit conversion could be expensive, so we avoid it here
+        dx = other.x - self.x
+        dy = other.y - self.y
+        dz = other.z - self.z
+
+        return (dx * dx + dy * dy + dz * dz) ** 0.5

src/specklepy/objects/geometry/polyline.py

@@ -0,0 +1,76 @@
+from dataclasses import dataclass
+from typing import List
+
+from specklepy.objects.base import Base
+from specklepy.objects.geometry.point import Point
+from specklepy.objects.interfaces import ICurve, IHasUnits
+
+
+@dataclass(kw_only=True)
+class Polyline(Base, IHasUnits, ICurve, speckle_type="Objects.Geometry.Polyline"):
+    """
+    a polyline curve, defined by a set of vertices.
+    """
+    value: List[float]
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(value: {self.value}, units: {self.units})"
+
+    def is_closed(self, tolerance: float = 1e-6) -> bool:
+        """
+        check if the polyline is closed (start point equals end point within tolerance)
+        """
+        if len(self.value) < 6:  # need at least 2 points to be closed
+            return False
+
+        # compare first and last points
+        start = Point(
+            x=self.value[0],
+            y=self.value[1],
+            z=self.value[2],
+            units=self.units
+        )
+        end = Point(
+            x=self.value[-3],
+            y=self.value[-2],
+            z=self.value[-1],
+            units=self.units
+        )
+        return start.distance_to(end) <= tolerance
+
+    @property
+    def length(self) -> float:
+        return self.__dict__.get('_length', 0.0)
+
+    @length.setter
+    def length(self, value: float) -> None:
+        self.__dict__['_length'] = value
+
+    def calculate_length(self) -> float:
+        points = self.get_points()
+        total_length = 0.0
+        for i in range(len(points) - 1):
+            total_length += points[i].distance_to(points[i + 1])
+        if self.is_closed() and points:
+            total_length += points[-1].distance_to(points[0])
+        return total_length
+
+    def get_points(self) -> List[Point]:
+        """
+        converts the raw coordinate list into Point objects
+        """
+        if len(self.value) % 3 != 0:
+            raise ValueError(
+                "Polyline value list is malformed: expected length to be multiple of 3"
+            )
+
+        points = []
+        for i in range(0, len(self.value), 3):
+            point = Point(
+                x=self.value[i],
+                y=self.value[i + 1],
+                z=self.value[i + 2],
+                units=self.units
+            )
+            points.append(point)
+        return points