chore(dev): bump to py 3.9 and fix end of line err

This makes it easier to develop and run tests against an environment that has the right python virtualenv + a local speckle server + postgres + redis instance

.circleci/config.yml

@@ -2,15 +2,14 @@ version: 2.1
 
 orbs:
   python: circleci/python@1.3.2
-  codecov: codecov/codecov@3.2.2
 
 jobs:
   test:
     docker:
       - image: "cimg/python:<<parameters.tag>>"
-      - image: 'cimg/node:14.18'
-      - image: 'circleci/redis:6'
-      - image: 'cimg/postgres:12.8'
+      - image: "circleci/node:12"
+      - image: "circleci/redis:6"
+      - image: "circleci/postgres:12"
         environment:
           POSTGRES_DB: speckle2_test
           POSTGRES_PASSWORD: speckle
@@ -39,15 +38,7 @@ jobs:
           name: upgrade pip
       - python/install-packages:
           pkg-manager: poetry
-      - run: poetry run pytest --cov --cov-report xml:reports/coverage.xml --junitxml=reports/test-results.xml
-
-      - store_test_results:
-          path: reports
-
-      - store_artifacts:
-          path: reports
-
-      - codecov/upload
+      - run: poetry run pytest
 
   deploy:
     docker:

.devcontainer/Dockerfile

@@ -0,0 +1,27 @@
+# See here for image contents: https://github.com/microsoft/vscode-dev-containers/tree/v0.191.1/containers/python-3/.devcontainer/base.Dockerfile
+
+# [Choice] Python version: 3, 3.9, 3.8, 3.7, 3.6
+ARG VARIANT="3.9"
+FROM mcr.microsoft.com/vscode/devcontainers/python:0-${VARIANT}
+
+# [Choice] Node.js version: none, lts/*, 16, 14, 12, 10
+ARG NODE_VERSION="none"
+RUN if [ "${NODE_VERSION}" != "none" ]; then su vscode -c "umask 0002 && . /usr/local/share/nvm/nvm.sh && nvm install ${NODE_VERSION} 2>&1"; fi
+
+# [Optional] If your pip requirements rarely change, uncomment this section to add them to the image.
+# COPY requirements.txt /tmp/pip-tmp/
+# RUN pip3 --disable-pip-version-check --no-cache-dir install -r /tmp/pip-tmp/requirements.txt \
+#    && rm -rf /tmp/pip-tmp
+
+# [Optional] Uncomment this section to install additional OS packages.
+# RUN apt-get update && export DEBIAN_FRONTEND=noninteractive \
+#     && apt-get -y install --no-install-recommends <your-package-list-here>
+
+# [Optional] Uncomment this line to install global node packages.
+# RUN su vscode -c "source /usr/local/share/nvm/nvm.sh && npm install -g <your-package-here>" 2>&1
+
+USER vscode
+
+RUN curl -sSL https://raw.githubusercontent.com/python-poetry/poetry/master/get-poetry.py | python -
+
+ENV PATH=$PATH:$HOME/.poetry/env

.devcontainer/devcontainer.json

@@ -0,0 +1,52 @@
+// For format details, see https://aka.ms/devcontainer.json. For config options, see the README at:
+// https://github.com/microsoft/vscode-dev-containers/tree/v0.191.1/containers/python-3
+{
+	"name": "Python 3",
+	// "build": {
+	// 	"dockerfile": "Dockerfile",
+	// 	"context": "..",
+	// 	"args": {
+	// 		// Update 'VARIANT' to pick a Python version: 3, 3.6, 3.7, 3.8, 3.9
+	// 		"VARIANT": "3.6",
+	// 		// Options
+	// 		"NODE_VERSION": "lts/*"
+	// 	}
+	// },
+	"dockerComposeFile": "./docker-compose.yaml",
+	"service": "specklepy",
+	"workspaceFolder": "/workspaces/specklepy",
+	"shutdownAction": "stopCompose",
+	// Set *default* container specific settings.json values on container create.
+	"settings": {
+		"python.pythonPath": "/usr/local/bin/python",
+		"python.languageServer": "Pylance",
+		"python.linting.enabled": true,
+		"python.linting.pylintEnabled": true,
+		"python.formatting.autopep8Path": "/usr/local/py-utils/bin/autopep8",
+		"python.formatting.blackPath": "/usr/local/py-utils/bin/black",
+		"python.formatting.yapfPath": "/usr/local/py-utils/bin/yapf",
+		"python.linting.banditPath": "/usr/local/py-utils/bin/bandit",
+		"python.linting.flake8Path": "/usr/local/py-utils/bin/flake8",
+		"python.linting.mypyPath": "/usr/local/py-utils/bin/mypy",
+		"python.linting.pycodestylePath": "/usr/local/py-utils/bin/pycodestyle",
+		"python.linting.pydocstylePath": "/usr/local/py-utils/bin/pydocstyle",
+		"python.linting.pylintPath": "/usr/local/py-utils/bin/pylint",
+		"python.testing.pytestArgs": [
+			"tests/",
+			"-s"
+		],
+		"python.testing.pytestEnabled": true,
+		"editor.formatOnSave": true,
+	},
+	// Add the IDs of extensions you want installed when the container is created.
+	"extensions": [
+		"ms-python.python",
+		"ms-python.vscode-pylance"
+	],
+	// Use 'forwardPorts' to make a list of ports inside the container available locally.
+	// "forwardPorts": [],
+	// Use 'postCreateCommand' to run commands after the container is created.
+	"postCreateCommand": "poetry config virtualenvs.create false && poetry install",
+	// Comment out connect as root instead. More info: https://aka.ms/vscode-remote/containers/non-root.
+	"remoteUser": "vscode"
+}

.devcontainer/docker-compose.yaml

@@ -0,0 +1,49 @@
+version: "3.3"  # optional since v1.27.0
+services:
+  postgres:
+    image: circleci/postgres:12
+    environment:
+      POSTGRES_DB: speckle2_test
+      POSTGRES_PASSWORD: speckle
+      POSTGRES_USER: speckle
+      # ports:
+      #   - "5432:5432"
+    network_mode: host
+  redis:
+    image: circleci/redis:6
+    # ports:
+    #   - "6379:6379"
+    network_mode: host
+  speckle-server:
+    image: speckle/speckle-server
+    command: ["bash", "-c", "/wait && node bin/www"]
+    environment:
+      POSTGRES_URL: "localhost"
+      POSTGRES_USER: "speckle"
+      POSTGRES_PASSWORD: "speckle"
+      POSTGRES_DB: "speckle2_test"
+      REDIS_URL: "redis://localhost"
+      SESSION_SECRET: "keyboard cat"
+      STRATEGY_LOCAL: "true"
+      CANONICAL_URL: "http://localhost:3000"
+      WAIT_HOSTS: localhost:5432, localhost:6379
+    # ports:
+    #   - "3000:3000"
+    network_mode: host
+
+  specklepy:
+    build:
+      dockerfile: Dockerfile
+      context: .
+      args:
+        VARIANT: 3.9
+        NODE_VERSION: lts/*
+    volumes:
+      # Mounts the project folder to '/workspace'. While this file is in .devcontainer,
+      # mounts are relative to the first file in the list, which is a level up.
+      - ..:/workspaces/specklepy:cached
+    # Overrides default command so things don't shut down after the process ends.
+    command: /bin/sh -c "while sleep 1000; do :; done"
+    network_mode: host
+# networks:
+#     default:

.gitattributes

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

.github/workflows/close-issue.yml

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

.github/workflows/open-issue.yml

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

.gitignore

@@ -1,7 +1,3 @@
-.tool-versions
-.envrc
-reports/
-
 # Byte-compiled / optimized / DLL files
 __pycache__/
 *.py[cod]

README.md

@@ -8,9 +8,7 @@
 <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>
+<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> </p>
 
 # About Speckle
 

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "specklepy"
-version = "2.4.0"
+version = "2.1.0"
 description = "The Python SDK for Speckle 2.0"
 readme = "README.md"
 authors = ["Speckle Systems <devops@speckle.systems>"]
@@ -12,17 +12,16 @@ homepage = "https://speckle.systems/"
 
 [tool.poetry.dependencies]
 python = "^3.6.5"
-pydantic = "^1.8.2"
+pydantic = "^1.7.3"
 appdirs = "^1.4.4"
-gql = {version = ">=3.0.0b1", extras = ["all"], allow-prereleases = true}
-ujson = "^4.3.0"
+gql = {version = ">=3.0.0a6", extras = ["all"], allow-prereleases = true}
+ujson = "^4.1.0"
 
 [tool.poetry.dev-dependencies]
 black = "^20.8b1"
 isort = "^5.7.0"
 pytest = "^6.2.2"
 pytest-ordering = "^0.6"
-pytest-cov = "^3.0.0"
 
 
 [tool.black]

specklepy/api/credentials.py

@@ -1,13 +1,12 @@
 import os
+from specklepy.transports.server.server import ServerTransport
 from warnings import warn
 from pydantic import BaseModel
 from typing import List, Optional
 from urllib.parse import urlparse, unquote
-from specklepy.logging import metrics
 from specklepy.api.models import ServerInfo
 from specklepy.api.client import SpeckleClient
 from specklepy.transports.sqlite import SQLiteTransport
-from specklepy.transports.server.server import ServerTransport
 from specklepy.logging.exceptions import SpeckleException, SpeckleWarning
 
 
@@ -42,7 +41,6 @@ def get_local_accounts(base_path: str = None) -> List[Account]:
     Returns:
         List[Account] -- list of all local accounts or an empty list if no accounts were found
     """
-    metrics.track(metrics.ACCOUNT_LIST)
     account_storage = SQLiteTransport(scope="Accounts", base_path=base_path)
     json_path = os.path.join(account_storage._base_path, "Accounts")
     os.makedirs(json_path, exist_ok=True)
@@ -75,7 +73,6 @@ def get_default_account(base_path: str = None) -> Account:
     Returns:
         Account -- the default account or None if no local accounts were found
     """
-    metrics.track(metrics.ACCOUNT_DEFAULT)
     accounts = get_local_accounts(base_path=base_path)
     if not accounts:
         return None
@@ -89,28 +86,6 @@ def get_default_account(base_path: str = None) -> Account:
 
 
 class StreamWrapper:
-    """
-    The `StreamWrapper` gives you some handy helpers to deal with urls and get authenticated clients and transports.
-
-    Construct a `StreamWrapper` with a stream, branch, commit, or object URL. The corresponding ids will be stored
-    in the wrapper. If you have local accounts on the machine, you can use the `get_account` and `get_client` methods
-    to get a local account for the server. You can also pass a token into `get_client` if you don't have a corresponding
-    local account for the server.
-
-    ```py
-    from specklepy.api.credentials import StreamWrapper
-
-    # provide any stream, branch, commit, object, or globals url
-    wrapper = StreamWrapper("https://speckle.xyz/streams/3073b96e86/commits/604bea8cc6")
-
-    # get an authenticated SpeckleClient if you have a local account for the server
-    client = wrapper.get_client()
-
-    # get an authenticated ServerTransport if you have a local account for the server
-    transport = wrapper.get_transport()
-    ```
-    """
-
     stream_url: str = None
     use_ssl: bool = True
     host: str = None
@@ -139,14 +114,13 @@ class StreamWrapper:
             return "stream" if self.stream_id else "invalid"
 
     def __init__(self, url: str) -> None:
-        metrics.track("streamwrapper")
         self.stream_url = url
         parsed = urlparse(url)
         self.host = parsed.netloc
         self.use_ssl = parsed.scheme == "https"
-        segments = parsed.path.strip("/").split("/", 3)
+        segments = parsed.path.strip("/").split("/")
 
-        if not segments or len(segments) < 2:
+        if not segments or len(segments) > 4 or len(segments) < 2:
             raise SpeckleException(
                 f"Cannot parse {url} into a stream wrapper class - invalid URL provided."
             )
@@ -176,9 +150,6 @@ class StreamWrapper:
             )
 
     def get_account(self) -> Account:
-        """
-        Gets an account object for this server from the local accounts db (added via Speckle Manager or a json file)
-        """
         if self.account:
             return self.account
 
@@ -189,42 +160,23 @@ class StreamWrapper:
 
         return self.account
 
-    def get_client(self, token: str = None) -> SpeckleClient:
-        """
-        Gets an authenticated client for this server. You may provide a token if there aren't any local accounts on this
-        machine. If no account is found and no token is provided, an unauthenticated client is returned.
-
-        Arguments:
-            token {str} -- optional token if no local account is available (defaults to None)
-
-        Returns:
-            SpeckleClient -- authenticated with a corresponding local account or the provided token
-        """
-        if self.client and token is None:
+    def get_client(self) -> SpeckleClient:
+        if self.client:
             return self.client
 
         if not self.account:
             self.get_account()
 
-        if not self.client:
-            self.client = SpeckleClient(host=self.host, use_ssl=self.use_ssl)
+        self.client = SpeckleClient(host=self.host, use_ssl=self.use_ssl)
 
-        if self.account is None and token is None:
+        if self.account is None:
             warn(f"No local account found for server {self.host}", SpeckleWarning)
             return self.client
 
-        self.client.authenticate(self.account.token if self.account else token)
-
+        self.client.authenticate(self.account.token)
         return self.client
 
-    def get_transport(self, token: str = None) -> ServerTransport:
-        """
-        Gets a server transport for this stream using an authenticated client. If there is no local account for this
-        server and the client was not authenticated with a token, this will throw an exception.
-
-        Returns:
-            ServerTransport -- constructed for this stream with a pre-authenticated client
-        """
-        if not self.client or not self.client.me:
-            self.get_client(token)
-        return ServerTransport(self.stream_id, self.client)
+    def get_transport(self) -> ServerTransport:
+        if not self.client:
+            self.get_client()
+        return ServerTransport(self.client, self.stream_id)

specklepy/api/models.py

@@ -30,7 +30,7 @@ class Commit(BaseModel):
     parents: Optional[List[str]]
 
     def __repr__(self) -> str:
-        return f"Commit( id: {self.id}, message: {self.message}, referencedObject: {self.referencedObject}, authorName: {self.authorName}, branchName: {self.branchName}, createdAt: {self.createdAt} )"
+        return f"Commit( id: {self.id}, message: {self.message}, referencedObject: {self.referencedObject}, authorName: {self.authorName}, createdAt: {self.createdAt} )"
 
     def __str__(self) -> str:
         return self.__repr__()

specklepy/api/operations.py

@@ -1,7 +1,7 @@
 from typing import List
-from specklepy.logging import metrics
 from specklepy.objects.base import Base
 from specklepy.transports.sqlite import SQLiteTransport
+from specklepy.transports.server import ServerTransport
 from specklepy.logging.exceptions import SpeckleException
 from specklepy.transports.abstract_transport import AbstractTransport
 from specklepy.serialization.base_object_serializer import BaseObjectSerializer
@@ -22,7 +22,6 @@ def send(
     Returns:
         str -- the object id of the sent object
     """
-    metrics.track(metrics.SEND)
     if not transports and not use_default_cache:
         raise SpeckleException(
             message="You need to provide at least one transport: cannot send with an empty transport list and no default cache"
@@ -58,7 +57,7 @@ def receive(
     Returns:
         Base -- the base object
     """
-    metrics.track(metrics.RECEIVE)
+
     if not local_transport:
         local_transport = SQLiteTransport()
 
@@ -93,7 +92,6 @@ def serialize(base: Base, write_transports: List[AbstractTransport] = []) -> str
     Returns:
         str -- the serialized object
     """
-    metrics.track(metrics.SERIALIZE)
     serializer = BaseObjectSerializer(write_transports=write_transports)
 
     return serializer.write_json(base)[1]
@@ -111,7 +109,6 @@ def deserialize(obj_string: str, read_transport: AbstractTransport = None) -> Ba
     Returns:
         Base -- the deserialized object
     """
-    metrics.track(metrics.DESERIALIZE)
     if not read_transport:
         read_transport = SQLiteTransport()
 

specklepy/api/resources/commit.py

@@ -34,8 +34,8 @@ class Resource(ResourceBase):
                 stream(id: $stream_id) {
                     commit(id: $commit_id) {
                         id
-                        message
                         referencedObject
+                        message
                         authorId
                         authorName
                         authorAvatar
@@ -79,7 +79,6 @@ class Resource(ResourceBase):
                             authorId
                             authorName
                             authorAvatar
-                            branchName
                             createdAt
                             sourceApplication
                             totalChildrenCount
@@ -186,40 +185,3 @@ class Resource(ResourceBase):
         return self.make_request(
             query=query, params=params, return_type="commitDelete", parse_response=False
         )
-
-    def received(
-        self,
-        stream_id: str,
-        commit_id: str,
-        source_application: str = "python",
-        message: Optional[str] = None,
-    ) -> bool:
-        """
-        Mark a commit object a received by the source application.
-        """
-        query = gql(
-            """
-            mutation CommitReceive($receivedInput:CommitReceivedInput!){
-                commitReceive(input:$receivedInput)
-            }
-            """
-        )
-        params = {
-            "receivedInput": {
-                "sourceApplication": source_application,
-                "streamId": stream_id,
-                "commitId": commit_id,
-                "message": "message",
-            }
-        }
-
-        try:
-            return self.make_request(
-                query=query,
-                params=params,
-                return_type="commitReceive",
-                parse_response=False,
-            )
-        except Exception as ex:
-            print(ex.with_traceback)
-            return False

specklepy/api/resources/stream.py

@@ -1,9 +1,7 @@
-from gql import gql
 from typing import Dict, List, Optional
-from specklepy.logging import metrics
-from specklepy.api.models import Stream
+from gql import gql
 from specklepy.api.resource import ResourceBase
-
+from specklepy.api.models import Stream
 
 NAME = "stream"
 METHODS = [
@@ -37,7 +35,6 @@ class Resource(ResourceBase):
         Returns:
             Stream -- the retrieved stream
         """
-        metrics.track(metrics.STREAM_GET)
         query = gql(
             """
             query Stream($id: String!, $branch_limit: Int!, $commit_limit: Int!) {
@@ -93,7 +90,6 @@ class Resource(ResourceBase):
         Returns:
             List[Stream] -- A list of Stream objects
         """
-        metrics.track(metrics.STREAM_LIST)
         query = gql(
             """
             query User($stream_limit: Int!) {
@@ -151,7 +147,6 @@ class Resource(ResourceBase):
         Returns:
             id {str} -- the id of the newly created stream
         """
-        metrics.track(metrics.STREAM_CREATE)
         query = gql(
             """
             mutation StreamCreate($stream: StreamCreateInput!) {
@@ -182,7 +177,6 @@ class Resource(ResourceBase):
         Returns:
             bool -- whether the stream update was successful
         """
-        metrics.track(metrics.STREAM_UPDATE)
         query = gql(
             """
             mutation StreamUpdate($stream: StreamUpdateInput!) {
@@ -213,7 +207,6 @@ class Resource(ResourceBase):
         Returns:
             bool -- whether the deletion was successful
         """
-        metrics.track(metrics.STREAM_DELETE)
         query = gql(
             """
             mutation StreamDelete($id: String!) {
@@ -246,7 +239,6 @@ class Resource(ResourceBase):
         Returns:
             List[Stream] -- a list of Streams that match the search query
         """
-        metrics.track(metrics.STREAM_SEARCH)
         query = gql(
             """
             query StreamSearch($search_query: String!,$limit: Int!, $branch_limit:Int!, $commit_limit:Int!) {

specklepy/logging/exceptions.py

@@ -32,4 +32,4 @@ class GraphQLException(SpeckleException):
 
 class SpeckleWarning(Warning):
     def __init__(self, *args: object) -> None:
-        super().__init__(*args)
+        super().__init__(*args)

specklepy/logging/metrics.py

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

specklepy/objects/base.py

@@ -1,20 +1,11 @@
 import typing
-from typing import (
-    Any,
-    Callable,
-    ClassVar,
-    Dict,
-    List,
-    Optional,
-    Set,
-    Type,
-    get_type_hints,
-)
 from warnings import warn
-
+from typing import get_type_hints
+from typing import ClassVar, Dict, List, Optional, Any, Set, Type
+from specklepy.transports.memory import MemoryTransport
 from specklepy.logging.exceptions import SpeckleException
 from specklepy.objects.units import get_units_from_string
-from specklepy.transports.memory import MemoryTransport
+
 
 PRIMITIVES = (int, float, str, bool)
 
@@ -71,8 +62,6 @@ REMOVE_FROM_DIR = {
     "to_dict",
     "update_forward_refs",
     "validate_prop_name",
-    "from_list",
-    "to_list",
 }
 
 
@@ -104,7 +93,6 @@ class _RegisteringBase:
         speckle_type: str = None,
         chunkable: Dict[str, int] = None,
         detachable: Set[str] = None,
-        serialize_ignore: Set[str] = None,
         **kwargs: Dict[str, Any],
     ):
         """
@@ -131,8 +119,6 @@ class _RegisteringBase:
             cls._chunkable = dict(cls._chunkable, **chunkable)
         if detachable:
             cls._detachable = cls._detachable.union(detachable)
-        if serialize_ignore:
-            cls._serialize_ignore = cls._serialize_ignore.union(serialize_ignore)
         super().__init_subclass__(**kwargs)
 
 
@@ -141,11 +127,9 @@ class Base(_RegisteringBase):
     totalChildrenCount: Optional[int] = None
     applicationId: Optional[str] = None
     _units: str = "m"
-    # dict of chunkable props and their max chunk size
-    _chunkable: Dict[str, int] = {}
+    _chunkable: Dict[str, int] = {}  # dict of chunkable props and their max chunk size
     _chunk_size_default: int = 1000
     _detachable: Set[str] = set()  # list of defined detachable props
-    _serialize_ignore: Set[str] = set()
 
     def __init__(self, **kwargs) -> None:
         super().__init__()
@@ -207,7 +191,7 @@ class Base(_RegisteringBase):
             try:
                 attr.__set__(self, value)
             except AttributeError:
-                return  # the prop probably doesn't have a setter
+                pass  # the prop probably doesn't have a setter
         super().__setattr__(name, value)
 
     @classmethod
@@ -254,12 +238,7 @@ class Base(_RegisteringBase):
 
         if t.__module__ == "typing":
             origin = getattr(t, "__origin__")
-            t = (
-                tuple(getattr(sub_t, "__origin__", sub_t) for sub_t in t.__args__)
-                if origin is typing.Union
-                else origin
-            )
-
+            t = t.__args__ if origin is typing.Union else origin
             if not isinstance(t, (type, tuple)):
                 warn(
                     f"Unrecognised type '{t}' provided for attribute '{name}'. Type will not been validated."
@@ -270,16 +249,13 @@ class Base(_RegisteringBase):
 
         # to be friendly, we'll parse ints and strs into floats, but not the other way around
         # (to avoid unexpected rounding)
-        if isinstance(t, tuple):
-            t = t[0]
-
-        try:
-            if t is float:
+        if t is float and isinstance(value, (int, str, float)):
+            try:
                 return float(value)
-            if t is str and value:
-                return str(value)
-        except ValueError:
-            pass
+            except ValueError:
+                pass
+        if t is str and value is not None:
+            return str(value)
 
         raise SpeckleException(
             f"Cannot set '{self.__class__.__name__}.{name}': it expects type '{t.__name__}', but received type '{type(value).__name__}'"
@@ -312,8 +288,36 @@ class Base(_RegisteringBase):
     def units(self, value: str):
         self._units = get_units_from_string(value)
 
+    # def to_dict(self) -> Dict[str, Any]:
+    #     """Convenience method to view the whole base object as a dict"""
+    #     base_dict = self.__dict__
+    #     for key, value in base_dict.items():
+    #         if not value or isinstance(value, PRIMITIVES):
+    #             continue
+    #         else:
+    #             base_dict[key] = self.__dict_helper(value)
+    #     return base_dict
+
+    # def __dict_helper(self, obj: Any) -> Any:
+    #     if not obj or isinstance(obj, PRIMITIVES):
+    #         return obj
+    #     if isinstance(obj, Base):
+    #         return self.__dict_helper(obj.__dict__)
+    #     if isinstance(obj, (list, set)):
+    #         return [self.__dict_helper(v) for v in obj]
+    #     if not isinstance(obj, dict):
+    #         raise SpeckleException(
+    #             message=f"Could not convert to dict due to unrecognized type: {type(obj)}"
+    #         )
+
+    #     for k, v in obj.items():
+    #         if v and not isinstance(obj, PRIMITIVES):
+    #             obj[k] = self.__dict_helper(v)
+    #     return obj
+
     def get_member_names(self) -> List[str]:
         """Get all of the property names on this object, dynamic or not"""
+        # attrs = set(self.__dict__.keys())
         attr_dir = list(set(dir(self)) - REMOVE_FROM_DIR)
         return [
             name
@@ -321,10 +325,6 @@ class Base(_RegisteringBase):
             if not name.startswith("_") and not callable(getattr(self, name))
         ]
 
-    def get_serializable_attributes(self) -> List[str]:
-        """Get the attributes that should be serialized"""
-        return list(set(self.get_member_names()) - self._serialize_ignore)
-
     def get_typed_member_names(self) -> List[str]:
         """Get all of the names of the defined (typed) properties of this object"""
         return list(self._attr_types.keys())
@@ -340,8 +340,7 @@ class Base(_RegisteringBase):
 
     def get_id(self, decompose: bool = False) -> str:
         """
-        Gets the id (a unique hash) of this object. ⚠️ This method fully serializes the object which,
-        in the case of large objects (with many sub-objects), has a tangible cost. Avoid using it!
+        Gets the id (a unique hash) of this object. ⚠️ This method fully serializes the object, which in the case of large objects (with many sub-objects), has a tangible cost. Avoid using it!
 
         Note: the hash of a decomposed object differs from that of a non-decomposed object
 
@@ -351,7 +350,9 @@ class Base(_RegisteringBase):
         Returns:
             str -- the hash (id) of the fully serialized object
         """
-        from specklepy.serialization.base_object_serializer import BaseObjectSerializer
+        from specklepy.serialization.base_object_serializer import (
+            BaseObjectSerializer,
+        )
 
         serializer = BaseObjectSerializer()
         if decompose:

specklepy/objects/encoding.py

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

specklepy/objects/geometry.py

@@ -1,9 +1,5 @@
-from enum import Enum
-from typing import Any, List, Optional
-
 from .base import Base
-from .encoding import CurveArray, CurveTypeEncoding, ObjectArray
-from .units import get_encoding_from_units, get_units_from_encoding
+from typing import Any, List
 
 GEOMETRY = "Objects.Geometry."
 
@@ -15,13 +11,6 @@ class Interval(Base, speckle_type="Objects.Primitive.Interval"):
     def length(self):
         return abs(self.start - self.end)
 
-    @classmethod
-    def from_list(cls, args: List[Any]) -> "Interval":
-        return cls(start=args[0], end=args[1])
-
-    def to_list(self) -> List[Any]:
-        return [self.start, self.end]
-
 
 class Point(Base, speckle_type=GEOMETRY + "Point"):
     x: float = 0.0
@@ -32,14 +21,7 @@ class Point(Base, speckle_type=GEOMETRY + "Point"):
         return f"{self.__class__.__name__}(x: {self.x}, y: {self.y}, z: {self.z}, id: {self.id}, speckle_type: {self.speckle_type})"
 
     @classmethod
-    def from_list(cls, args: List[float]) -> "Point":
-        return cls(x=args[0], y=args[1], z=args[2])
-
-    def to_list(self) -> List[Any]:
-        return [self.x, self.y, self.z]
-
-    @classmethod
-    def from_coords(cls, x: float = 0.0, y: float = 0.0, z: float = 0.0):
+    def from_coords(x: float = 0.0, y: float = 0.0, z: float = 0.0):
         pt = Point()
         pt.x, pt.y, pt.z = x, y, z
         return pt
@@ -59,23 +41,6 @@ class Plane(Base, speckle_type=GEOMETRY + "Plane"):
     xdir: Vector = Vector()
     ydir: Vector = Vector()
 
-    @classmethod
-    def from_list(cls, args: List[Any]) -> "Plane":
-        return cls(
-            origin=Point.from_list(args[0:3]),
-            normal=Vector.from_list(args[3:6]),
-            xdir=Vector.from_list(args[6:9]),
-            ydir=Vector.from_list(args[9:12]),
-        )
-
-    def to_list(self) -> List[Any]:
-        encoded = []
-        encoded.extend(self.origin.to_list())
-        encoded.extend(self.normal.to_list())
-        encoded.extend(self.xdir.to_list())
-        encoded.extend(self.ydir.to_list())
-        return encoded
-
 
 class Box(Base, speckle_type=GEOMETRY + "Box"):
     basePlane: Plane = Plane()
@@ -93,21 +58,6 @@ class Line(Base, speckle_type=GEOMETRY + "Line"):
     bbox: Box = None
     length: float = None
 
-    @classmethod
-    def from_list(cls, args: List[Any]) -> "Line":
-        return cls(
-            start=Point.from_list(args[0:3]),
-            end=Point.from_list(args[3:6]),
-            domain=Interval.from_list(args[6:9]),
-        )
-
-    def to_list(self) -> List[Any]:
-        encoded = []
-        encoded.extend(self.start.to_list())
-        encoded.extend(self.end.to_list())
-        encoded.extend(self.domain.to_list())
-        return encoded
-
 
 class Arc(Base, speckle_type=GEOMETRY + "Arc"):
     radius: float = None
@@ -123,30 +73,6 @@ class Arc(Base, speckle_type=GEOMETRY + "Arc"):
     area: float = None
     length: float = None
 
-    @classmethod
-    def from_list(cls, args: List[Any]) -> "Arc":
-        return cls(
-            radius=args[1],
-            startAngle=args[2],
-            endAngle=args[3],
-            angleRadians=args[4],
-            domain=Interval.from_list(args[5:7]),
-            plane=Plane.from_list(args[7:20]),
-            units=get_units_from_encoding(args[-1]),
-        )
-
-    def to_list(self) -> List[Any]:
-        encoded = []
-        encoded.append(CurveTypeEncoding.Arc.value)
-        encoded.append(self.radius)
-        encoded.append(self.startAngle)
-        encoded.append(self.endAngle)
-        encoded.append(self.angleRadians)
-        encoded.extend(self.domain.to_list())
-        encoded.extend(self.plane.to_list())
-        encoded.append(get_encoding_from_units(self.units))
-        return encoded
-
 
 class Circle(Base, speckle_type=GEOMETRY + "Circle"):
     radius: float = None
@@ -156,24 +82,6 @@ class Circle(Base, speckle_type=GEOMETRY + "Circle"):
     area: float = None
     length: float = None
 
-    @classmethod
-    def from_list(cls, args: List[Any]) -> "Circle":
-        return cls(
-            radius=args[1],
-            domain=Interval.from_list(args[2:4]),
-            plane=Plane.from_list(args[4:17]),
-            units=get_units_from_encoding(args[-1]),
-        )
-
-    def to_list(self) -> List[Any]:
-        encoded = []
-        encoded.append(CurveTypeEncoding.Circle.value)
-        encoded.append(self.radius),
-        encoded.extend(self.domain.to_list())
-        encoded.extend(self.plane.to_list())
-        encoded.append(get_encoding_from_units(self.units))
-        return encoded
-
 
 class Ellipse(Base, speckle_type=GEOMETRY + "Ellipse"):
     firstRadius: float = None
@@ -185,26 +93,6 @@ class Ellipse(Base, speckle_type=GEOMETRY + "Ellipse"):
     area: float = None
     length: float = None
 
-    @classmethod
-    def from_list(cls, args: List[Any]) -> "Ellipse":
-        return cls(
-            firstRadius=args[1],
-            secondRadius=args[2],
-            domain=Interval.from_list(args[3:5]),
-            plane=Plane.from_list(args[5:18]),
-            units=get_units_from_encoding(args[-1]),
-        )
-
-    def to_list(self) -> List[Any]:
-        encoded = []
-        encoded.append(CurveTypeEncoding.Ellipse.value)
-        encoded.append(self.firstRadius)
-        encoded.append(self.secondRadius)
-        encoded.extend(self.domain.to_list())
-        encoded.extend(self.plane.to_list())
-        encoded.append(get_encoding_from_units(self.units))
-        return encoded
-
 
 class Polyline(Base, speckle_type=GEOMETRY + "Polyline", chunkable={"value": 20000}):
     value: List[float] = None
@@ -223,25 +111,15 @@ class Polyline(Base, speckle_type=GEOMETRY + "Polyline", chunkable={"value": 200
             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]),
-        )
+    # @property
+    # def value(self) -> List[float]:
+    #     return self._value
 
-    def to_list(self) -> List[Any]:
-        encoded = []
-        encoded.append(CurveTypeEncoding.Polyline.value)
-        encoded.append(int(self.closed))
-        encoded.extend(self.domain.to_list())
-        encoded.append(len(self.value))
-        encoded.extend(self.value)
-        encoded.append(get_encoding_from_units(self.units))
-        return encoded
+    # @value.setter
+    # def value(self, coords) -> None:
+    #     if len(coords) % 3:
+    #         coords.extend([0] * (3 - len(coords) % 3))
+    #     self._value = coords
 
     def as_points(self) -> List[Point]:
         """Converts the `value` attribute to a list of Points"""
@@ -288,46 +166,6 @@ class Curve(
             Point(x=v, y=next(values), z=next(values), units=self.units) for v in values
         ]
 
-    @classmethod
-    def from_list(cls, args: List[Any]) -> "Curve":
-        point_count = args[7]
-        weights_count = args[8]
-        knots_count = args[9]
-
-        points_start = 10
-        weights_start = 10 + point_count
-        knots_start = weights_start + weights_count
-        knots_end = knots_start + knots_count
-
-        return cls(
-            degree=args[1],
-            periodic=bool(args[2]),
-            rational=bool(args[3]),
-            closed=bool(args[4]),
-            domain=Interval.from_list(args[5:7]),
-            points=args[points_start:weights_start],
-            weights=args[weights_start:knots_start],
-            knots=args[knots_start:knots_end],
-            units=get_units_from_encoding(args[-1]),
-        )
-
-    def to_list(self) -> List[Any]:
-        encoded = []
-        encoded.append(CurveTypeEncoding.Curve.value)
-        encoded.append(self.degree)
-        encoded.append(int(self.periodic))
-        encoded.append(int(self.rational))
-        encoded.append(int(self.closed))
-        encoded.extend(self.domain.to_list())
-        encoded.append(len(self.points))
-        encoded.append(len(self.weights))
-        encoded.append(len(self.knots))
-        encoded.extend(self.points)
-        encoded.extend(self.weights)
-        encoded.extend(self.knots)
-        encoded.append(get_encoding_from_units(self.units))
-        return encoded
-
 
 class Polycurve(Base, speckle_type=GEOMETRY + "Polycurve"):
     segments: List[Base] = None
@@ -337,27 +175,6 @@ class Polycurve(Base, speckle_type=GEOMETRY + "Polycurve"):
     area: float = None
     length: float = None
 
-    @classmethod
-    def from_list(cls, args: List[Any]) -> "Polycurve":
-        curve_arrays = CurveArray()
-        curve_arrays.data = args[4:-1]
-        return cls(
-            closed=bool(args[1]),
-            domain=Interval.from_list(args[2:4]),
-            segments=curve_arrays.to_curves(),
-            units=get_units_from_encoding(args[-1]),
-        )
-
-    def to_list(self) -> List[Any]:
-        encoded = []
-        encoded.append(CurveTypeEncoding.Polycurve.value)
-        encoded.append(int(self.closed))
-        encoded.extend(self.domain.to_list())
-        curve_array = CurveArray.from_curves(self.segments)
-        encoded.extend(curve_array.data)
-        encoded.append(get_encoding_from_units(self.units))
-        return encoded
-
 
 class Extrusion(Base, speckle_type=GEOMETRY + "Extrusion"):
     capped: bool = None
@@ -391,15 +208,6 @@ class Mesh(
     area: float = None
     volume: float = None
 
-    def transform_to(self, transform: "Transform") -> "Mesh":
-        mesh = Mesh(vertices=transform.apply_to_points_values(self.vertices))
-        for attr in set(self.get_serializable_attributes()) - {"vertices"}:
-            orig_val = getattr(self, attr, None)
-            if orig_val:
-                setattr(mesh, attr, orig_val)
-
-        return mesh
-
 
 class Surface(Base, speckle_type=GEOMETRY + "Surface"):
     degreeU: int = None
@@ -410,58 +218,6 @@ class Surface(Base, speckle_type=GEOMETRY + "Surface"):
     countU: int = None
     countV: int = None
     bbox: Box = None
-    closedU: bool = None
-    closedV: bool = None
-    domainU: Interval = None
-    domainV: Interval = None
-    knotsU: List[float] = None
-    knotsV: List[float] = None
-
-    @classmethod
-    def from_list(cls, args: List[Any]) -> "Surface":
-        point_count = int(args[11])
-        knots_u_count = int(args[12])
-        knots_v_count = int(args[13])
-
-        start_point_data = 14
-        start_knots_u = start_point_data + point_count
-        start_knots_v = start_knots_u + knots_u_count
-
-        return cls(
-            degreeU=int(args[0]),
-            degreeV=int(args[1]),
-            countU=int(args[2]),
-            countV=int(args[3]),
-            rational=bool(args[4]),
-            closedU=bool(args[5]),
-            closedV=bool(args[6]),
-            domainU=Interval(start=args[7], end=args[8]),
-            domainV=Interval(start=args[9], end=args[10]),
-            pointData=args[start_point_data:start_knots_u],
-            knotsU=args[start_knots_u:start_knots_v],
-            knotsV=args[start_knots_v : start_knots_v + knots_v_count],
-            units=get_units_from_encoding(args[-1]),
-        )
-
-    def to_list(self) -> List[Any]:
-        encoded = []
-        encoded.append(self.degreeU)
-        encoded.append(self.degreeV)
-        encoded.append(self.countU)
-        encoded.append(self.countV)
-        encoded.append(int(self.rational))
-        encoded.append(int(self.closedU))
-        encoded.append(int(self.closedV))
-        encoded.extend(self.domainU.to_list())
-        encoded.extend(self.domainV.to_list())
-        encoded.append(len(self.pointData))
-        encoded.append(len(self.knotsU))
-        encoded.append(len(self.knotsV))
-        encoded.extend(self.pointData)
-        encoded.extend(self.knotsU)
-        encoded.extend(self.knotsV)
-        encoded.append(get_encoding_from_units(self.units))
-        return encoded
 
 
 class BrepFace(Base, speckle_type=GEOMETRY + "BrepFace"):
@@ -528,17 +284,6 @@ class BrepLoop(Base, speckle_type=GEOMETRY + "BrepLoop"):
             return [self._Brep.Trims[i] for i in self.TrimIndices]
 
 
-class BrepTrimTypeEnum(int, Enum):
-    Unknown = 0
-    Boundary = 1
-    Mated = 2
-    Seam = 3
-    Singular = 4
-    CurveOnSurface = 5
-    PointOnSurface = 6
-    Slit = 7
-
-
 class BrepTrim(Base, speckle_type=GEOMETRY + "BrepTrim"):
     _Brep: "Brep" = None
     EdgeIndex: int = None
@@ -568,49 +313,21 @@ class BrepTrim(Base, speckle_type=GEOMETRY + "BrepTrim"):
     def _curve_2d(self):
         return self._Brep.Curve2D[self.CurveIndex]
 
-    @classmethod
-    def from_list(cls, args: List[Any]) -> "BrepTrim":
-        return cls(
-            EdgeIndex=args[0],
-            StartIndex=args[1],
-            EndIndex=args[2],
-            FaceIndex=args[3],
-            LoopIndex=args[4],
-            CurveIndex=args[5],
-            IsoStatus=args[6],
-            TrimType=BrepTrimTypeEnum(args[7]).name,
-            IsReversed=bool(args[8]),
-        )
-
-    def to_list(self) -> List[Any]:
-        encoded = []
-        encoded.append(self.EdgeIndex)
-        encoded.append(self.StartIndex)
-        encoded.append(self.EndIndex)
-        encoded.append(self.FaceIndex)
-        encoded.append(self.LoopIndex)
-        encoded.append(self.CurveIndex)
-        encoded.append(self.IsoStatus)
-        encoded.append(getattr(BrepTrimTypeEnum, self.TrimType).value)
-        encoded.append(self.IsReversed)
-        return encoded
-
 
 class Brep(
     Base,
     speckle_type=GEOMETRY + "Brep",
     chunkable={
-        "SurfacesValue": 200,
-        "Curve3DValues": 200,
-        "Curve2DValues": 200,
-        "VerticesValue": 5000,
+        "Surfaces": 200,
+        "Curve3D": 200,
+        "Curve2D": 200,
+        "Vertices": 5000,
         "Edges": 5000,
         "Loops": 5000,
-        "TrimsValue": 5000,
+        "Trims": 5000,
         "Faces": 5000,
     },
     detachable={"displayValue"},
-    serialize_ignore={"Surfaces", "Curve3D", "Curve2D", "Vertices", "Trims"},
 ):
     provenance: str = None
     bbox: Box = None
@@ -621,121 +338,20 @@ class Brep(
     Curve3D: List[Base] = None
     Curve2D: List[Base] = None
     Vertices: List[Point] = None
+    Edges: List[BrepEdge] = None
+    Loops: List[BrepLoop] = None
+    Trims: List[BrepTrim] = None
+    Faces: List[BrepFace] = None
     IsClosed: bool = None
     Orientation: int = None
 
-    def _inject_self_into_children(self, children: Optional[List[Base]]) -> List[Base]:
-        if children is None:
-            return children
-
-        for child in children:
-            child._Brep = self
-        return children
-
-    @property
-    def Edges(self) -> List[BrepEdge]:
-        return self._inject_self_into_children(self._Edges)
-
-    @Edges.setter
-    def Edges(self, value: List[BrepEdge]):
-        self._Edges = value
-
-    @property
-    def Loops(self) -> List[BrepLoop]:
-        return self._inject_self_into_children(self._Loops)
-
-    @Loops.setter
-    def Loops(self, value: List[BrepLoop]):
-        self._Loops = value
-
-    @property
-    def Faces(self) -> List[BrepFace]:
-        return self._inject_self_into_children(self._Faces)
-
-    @Faces.setter
-    def Faces(self, value: List[BrepFace]):
-        self._Faces = value
-
-    @property
-    def SurfacesValue(self) -> List[float]:
-        if self.Surfaces is None:
-            return None
-        return ObjectArray.from_objects(self.Surfaces).data
-
-    @SurfacesValue.setter
-    def SurfacesValue(self, value: List[float]):
-        self.Surfaces = ObjectArray.decode_data(value, Surface.from_list)
-
-    @property
-    def Curve3DValues(self) -> List[float]:
-        if self.Curve3D is None:
-            return None
-        return CurveArray.from_curves(self.Curve3D).data
-
-    @Curve3DValues.setter
-    def Curve3DValues(self, value: List[float]):
-        crv_array = CurveArray()
-        crv_array.data = value
-        self.Curve3D = crv_array.to_curves()
-
-    @property
-    def Curve2DValues(self) -> List[Base]:
-        if self.Curve2D is None:
-            return None
-        return CurveArray.from_curves(self.Curve2D).data
-
-    @Curve2DValues.setter
-    def Curve2DValues(self, value: List[float]):
-        crv_array = CurveArray()
-        crv_array.data = value
-        self.Curve2D = crv_array.to_curves()
-
-    @property
-    def VerticesValue(self) -> List[Point]:
-        if self.Vertices is None:
-            return None
-        encoded_unit = get_encoding_from_units(self.Vertices[0].units)
-        values = [encoded_unit]
-        for vertex in self.Vertices:
-            values.extend(vertex.to_list())
-        return values
-
-    @VerticesValue.setter
-    def VerticesValue(self, value: List[float]):
-        value = value.copy()
-        units = get_units_from_encoding(value.pop(0))
-
-        vertices = []
-
-        for i in range(0, len(value), 3):
-            vertex = Point.from_list(value[i : i + 3])
-            vertex._units = units
-            vertices.append(vertex)
-
-        self.Vertices = vertices
-
-    @property
-    def Trims(self) -> List[BrepTrim]:
-        return self._inject_self_into_children(self._Trims)
-
-    @Trims.setter
-    def Trims(self, value: List[BrepTrim]):
-        self._Trims = value
-
-    @property
-    def TrimsValue(self) -> List[float]:
-        if self.Trims is None:
-            return None
-        values = []
-        for trim in self.Trims:
-            values.extend(trim.to_list())
-        return values
-
-    @TrimsValue.setter
-    def TrimsValue(self, value: List[float]):
-        self.Trims = [
-            BrepTrim.from_list(value[i : i + 9]) for i in range(0, len(value), 9)
-        ]
+    def __setattr__(self, name: str, value: Any) -> None:
+        if not value:
+            return
+        if name in {"Edges", "Loops", "Trims", "Faces"}:
+            for val in value:
+                val._Brep = self
+        super().__setattr__(name, value)
 
 
 BrepEdge.update_forward_refs()

specklepy/objects/other.py

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

specklepy/objects/units.py

@@ -14,18 +14,6 @@ UNITS_STRINGS = {
     "none": ["none", "null"],
 }
 
-UNITS_ENCODINGS = {
-    "none": 0,
-    "mm": 1,
-    "cm": 2,
-    "m": 3,
-    "km": 4,
-    "in": 5,
-    "ft": 6,
-    "yd": 7,
-    "mi": 8,
-}
-
 
 def get_units_from_string(unit: str):
     unit = str.lower(unit)
@@ -36,22 +24,3 @@ def get_units_from_string(unit: str):
     raise SpeckleException(
         message=f"Could not understand what unit {unit} is referring to. Please enter a valid unit (eg {UNITS})."
     )
-
-
-def get_units_from_encoding(unit: int):
-    for name, encoding in UNITS_ENCODINGS.items():
-        if unit == encoding:
-            return name
-
-    raise SpeckleException(
-        message=f"Could not understand what unit {unit} is referring to. Please enter a valid unit encoding (eg {UNITS_ENCODINGS})."
-    )
-
-
-def get_encoding_from_units(unit: str):
-    try:
-        return UNITS_ENCODINGS[unit]
-    except KeyError:
-        raise SpeckleException(
-            message=f"No encoding exists for unit {unit}. Please enter a valid unit to encode (eg {UNITS_ENCODINGS})."
-        )

specklepy/serialization/base_object_serializer.py

@@ -52,7 +52,7 @@ class BaseObjectSerializer:
         self.lineage.append(uuid4().hex)
         object_builder = {"id": "", "speckle_type": "Base", "totalChildrenCount": 0}
         object_builder.update(speckle_type=base.speckle_type)
-        obj, props = base, base.get_serializable_attributes()
+        obj, props = base, base.get_member_names()
 
         while props:
             prop = props.pop(0)

specklepy/transports/server/batch_sender.py

@@ -102,9 +102,7 @@ class BatchSender(object):
         new_objects = [obj[1] for obj in batch if obj[0] in new_object_ids]
 
         if not new_objects:
-            LOG.info(
-                f"Uploading batch of {len(batch)} objects: all objects are already in the server"
-            )
+            LOG.info(f"Uploading batch of {len(batch)} objects: all objects are already in the server")
             return
 
         upload_data = "[" + ",".join(new_objects) + "]"
@@ -114,30 +112,24 @@ class BatchSender(object):
             % (len(batch), len(new_objects), len(upload_data), len(upload_data_gzip))
         )
 
-        try:
-            r = session.post(
-                url=f"{self.server_url}/objects/{self.stream_id}",
-                files={"batch-1": ("batch-1", upload_data_gzip, "application/gzip")},
-            )
-            if r.status_code != 201:
-                LOG.warning("Upload server response: %s", r.text)
-                raise SpeckleException(
-                    message=f"Could not save the object to the server - status code {r.status_code}"
-                )
-        except json.JSONDecodeError as error:
-            return SpeckleException(
-                f"Failed to send objects to {self.server_url}. Please ensure this stream ({self.stream_id}) exists on this server and that you have permission to send to it.",
-                error,
+        r = session.post(
+            url=f"{self.server_url}/objects/{self.stream_id}",
+            files={"batch-1": ("batch-1", upload_data_gzip, "application/gzip")},
+        )
+        if r.status_code != 201:
+            LOG.warning("Upload server response: %s", r.text)
+            raise SpeckleException(
+                message=f"Could not save the object to the server - status code {r.status_code}"
             )
 
     def _create_threads(self):
-        for _ in range(self.thread_count):
+        for i in range(self.thread_count):
             t = threading.Thread(target=self._sending_thread_main, daemon=True)
             t.start()
             self._send_threads.append(t)
 
     def _delete_threads(self):
-        for _ in range(len(self._send_threads)):
+        for i in range(len(self._send_threads)):
             self._batches.put(None)
 
         for thread in self._send_threads:

specklepy/transports/server/server.py

@@ -13,68 +13,21 @@ from .batch_sender import BatchSender
 
 
 class ServerTransport(AbstractTransport):
-    """
-    The `ServerTransport` is the vehicle through which you transport objects to and from a Speckle Server. Provide it to
-    `operations.send()` or `operations.receive()`.
-
-    The `ServerTransport` can be authenticted two different ways:
-        1. by providing a `SpeckleClient`
-        2. by providing a `token` and `url`
-
-    ```py
-    from specklepy.api import operations
-    from specklepy.transports.server import ServerTransport
-
-    # here's the data you want to send
-    block = Block(length=2, height=4)
-
-    # next create the server transport - this is the vehicle through which you will send and receive
-    transport = ServerTransport(stream_id=new_stream_id, client=client)
-
-    # this serialises the block and sends it to the transport
-    hash = operations.send(base=block, transports=[transport])
-
-    # you can now create a commit on your stream with this object
-    commid_id = client.commit.create(
-        stream_id=new_stream_id,
-        obj_id=hash,
-        message="this is a block I made in speckle-py",
-    )
-    ```
-    """
-
     _name = "RemoteTransport"
     url: str = None
     stream_id: str = None
     saved_obj_count: int = 0
     session: requests.Session = None
 
-    def __init__(
-        self,
-        stream_id: str,
-        client: SpeckleClient = None,
-        token: str = None,
-        url: str = None,
-        **data: Any,
-    ) -> None:
+    def __init__(self, client: SpeckleClient, stream_id: str, **data: Any) -> None:
         super().__init__(**data)
         # TODO: replace client with account or some other auth avenue
-        if client is None and token is None and url is None:
-            raise SpeckleException(
-                "You must provide either a client or a token and url to construct a ServerTransport."
-            )
-
-        if client:
-            if not client.me:
-                raise SpeckleException(
-                    "The provided SpeckleClient was not authenticated."
-                )
-            token = client.me["token"]
-            url = client.url
-
+        if not client.me:
+            raise SpeckleException("The provided SpeckleClient was not authenticated.")
+        self.url = client.url
         self.stream_id = stream_id
-        self.url = url
 
+        token = client.me["token"]
         self._batch_sender = BatchSender(
             self.url, self.stream_id, token, max_batch_size_mb=1
         )

specklepy/transports/sqlite.py

@@ -32,7 +32,7 @@ class SQLiteTransport(AbstractTransport):
         super().__init__(**data)
         self.app_name = app_name or "Speckle"
         self.scope = scope or "Objects"
-        self._base_path = base_path or self.get_base_path(self.app_name)
+        self._base_path = base_path or self.__get_base_path()
 
         try:
             os.makedirs(self._base_path, exist_ok=True)
@@ -56,8 +56,7 @@ class SQLiteTransport(AbstractTransport):
     #     proc.start()
     #     proc.join()
 
-    @staticmethod
-    def get_base_path(app_name):
+    def __get_base_path(self):
         # from appdirs https://github.com/ActiveState/appdirs/blob/master/appdirs.py
         # default mac path is not the one we use (we use unix path), so using special case for this
         system = sys.platform
@@ -69,10 +68,10 @@ class SQLiteTransport(AbstractTransport):
                 system = "darwin"
 
         if system != "darwin":
-            return user_data_dir(appname=app_name, appauthor=False, roaming=True)
+            return user_data_dir(appname=self.app_name, appauthor=False, roaming=True)
 
         path = os.path.expanduser("~/.config/")
-        return os.path.join(path, app_name)
+        return os.path.join(path, self.app_name)
 
     # def __consume_queue(self):
     #     if self._is_writing or self.__queue.empty():

tests/conftest.py

@@ -7,9 +7,6 @@ from specklepy.api.client import SpeckleClient
 from specklepy.objects.base import Base
 from specklepy.objects.geometry import Point
 from specklepy.objects.fakemesh import FakeMesh
-from specklepy.logging import metrics
-
-metrics.disable()
 
 
 @pytest.fixture(scope="session")

tests/test_base.py

@@ -1,10 +1,9 @@
-from contextlib import ExitStack as does_not_raise
-from typing import Dict, List, Optional
-
 import pytest
+from typing import Dict, List
+from specklepy.objects import Base
 from specklepy.api import operations
+from contextlib import ExitStack as does_not_raise
 from specklepy.logging.exceptions import SpeckleException
-from specklepy.objects.base import Base, DataChunk
 
 
 @pytest.mark.parametrize(
@@ -87,9 +86,9 @@ class FrozenYoghurt(Base):
     """Testing type checking"""
 
     servings: int
-    flavours: List[str]  # list item types won't be checked
+    flavours: List[str] = None  # list item types won't be checked
     customer: str
-    add_ons: Optional[Dict[str, float]]  # dict item types won't be checked
+    add_ons: Dict[str, float]  # dict item types won't be checked
     price: float = 0.0
 
 

tests/test_branch.py

@@ -58,7 +58,7 @@ class TestBranch:
         assert isinstance(branches, list)
         assert len(branches) == 2
         assert isinstance(branches[0], Branch)
-        assert branches[1].name == branch.name
+        assert branches[0].name == branch.name
 
     def test_branch_update(self, client, stream, branch, updated_branch):
         updated = client.branch.update(

tests/test_commit.py

@@ -68,20 +68,3 @@ class TestCommit:
         deleted = client.commit.delete(stream_id=stream.id, commit_id=commit_id)
 
         assert deleted is True
-
-    def test_commit_marked_as_received(self, client, stream, mesh) -> None:
-        commit = Commit(message="this commit should be received")
-        commit.id = client.commit.create(
-            stream_id=stream.id,
-            object_id=mesh.id,
-            message=commit.message,
-        )
-
-        commit_marked_received = client.commit.received(
-            stream.id,
-            commit.id,
-            source_application="pytest",
-            message="testing received",
-        )
-
-        assert commit_marked_received == True

tests/test_geometry.py

@@ -1,452 +0,0 @@
-import json
-from typing import Callable
-
-import pytest
-from specklepy.api import operations
-from specklepy.objects.base import Base
-from specklepy.objects.encoding import CurveArray, ObjectArray
-from specklepy.objects.geometry import (
-    Arc,
-    Box,
-    Brep,
-    BrepEdge,
-    BrepFace,
-    BrepLoop,
-    BrepTrim,
-    BrepTrimTypeEnum,
-    Circle,
-    Curve,
-    Ellipse,
-    Interval,
-    Line,
-    Mesh,
-    Plane,
-    Point,
-    Polycurve,
-    Polyline,
-    Surface,
-    Vector,
-)
-from specklepy.transports.memory import MemoryTransport
-
-
-@pytest.fixture()
-def interval():
-    return Interval(start=0, end=5)
-
-
-@pytest.fixture()
-def point():
-    return Point(x=1, y=10, z=0)
-
-
-@pytest.fixture()
-def vector():
-    return Vector(x=1, y=32, z=10)
-
-
-@pytest.fixture()
-def plane(point, vector):
-    return Plane(
-        origin=point,
-        normal=vector,
-        xdir=vector,
-        ydir=vector,
-    )
-
-
-@pytest.fixture()
-def box(plane, interval):
-    return Box(
-        basePlane=plane,
-        ySize=interval,
-        zSize=interval,
-        xSize=interval,
-        area=20.4,
-        volume=44.2,
-    )
-
-
-@pytest.fixture()
-def line(point, interval):
-    return Line(
-        start=point,
-        end=point,
-        domain=interval,
-        # These attributes are not handled in C#
-        # bbox=None,
-        # length=None
-    )
-
-
-@pytest.fixture()
-def arc(plane, interval):
-    return Arc(
-        radius=2.3,
-        startAngle=22.1,
-        endAngle=44.5,
-        angleRadians=33,
-        plane=plane,
-        domain=interval,
-        units="m",
-        # These attributes are not handled in C#
-        # bbox=None,
-        # area=None,
-        # length=None,
-        # startPoint=None,
-        # midPoint=None,
-        # endPoint=None,
-    )
-
-
-@pytest.fixture()
-def circle(plane, interval):
-    return Circle(
-        radius=22,
-        plane=plane,
-        domain=interval,
-        units="m",
-        # These attributes are not handled in C#
-        # bbox=None,
-        # area=None,
-        # length=None,
-    )
-
-
-@pytest.fixture()
-def ellipse(plane, interval):
-    return Ellipse(
-        firstRadius=34,
-        secondRadius=22,
-        plane=plane,
-        domain=interval,
-        units="m",
-        # These attributes are not handled in C#
-        # trimDomain=None,
-        # bbox=None,
-        # area=None,
-        # length=None,
-    )
-
-
-@pytest.fixture()
-def polyline(interval):
-    return Polyline(
-        value=[22, 44, 54.3, 99, 232, 21],
-        closed=True,
-        domain=interval,
-        units="m",
-        # These attributes are not handled in C#
-        # bbox=None,
-        # area=None,
-        # length=None,
-    )
-
-
-@pytest.fixture()
-def curve(interval):
-    return Curve(
-        degree=90,
-        periodic=True,
-        rational=False,
-        closed=True,
-        domain=interval,
-        points=[23, 21, 44, 43, 56, 76, 1, 3, 2],
-        weights=[23, 11, 23],
-        knots=[22, 45, 76, 11],
-        units="m",
-        # These attributes are not handled in C#
-        # displayValue=None,
-        # bbox=None,
-        # area=None,
-        # length=None,
-    )
-
-
-@pytest.fixture()
-def polycurve(interval, curve, polyline):
-    return Polycurve(
-        segments=[curve, polyline],
-        domain=interval,
-        closed=True,
-        units="m",
-        # These attributes are not handled in C#
-        # bbox=None,
-        # area=None,
-        # length=None
-    )
-
-
-@pytest.fixture()
-def mesh(box):
-    return Mesh(
-        vertices=[2, 1, 2, 4, 77.3, 5, 33, 4, 2],
-        faces=[1, 2, 3, 4, 5, 6, 7],
-        colors=[111, 222, 333, 444, 555, 666, 777],
-        bbox=box,
-        area=233,
-        volume=232.2,
-    )
-
-
-@pytest.fixture()
-def surface(interval):
-    return Surface(
-        degreeU=33,
-        degreeV=44,
-        rational=True,
-        pointData=[1, 2.2, 3, 4, 5, 6, 7, 8, 9],
-        countU=3,
-        countV=4,
-        closedU=True,
-        closedV=False,
-        domainU=interval,
-        domainV=interval,
-        knotsU=[1.1, 2.2, 3.3, 4.4],
-        knotsV=[9, 8, 7, 6, 5, 4.4],
-        units="m",
-        # These attributes are not handled in C#
-        # bbox=None,
-        # area=None,
-    )
-
-
-@pytest.fixture()
-def brep_face():
-    return BrepFace(
-        SurfaceIndex=3,
-        LoopIndices=[1, 2, 3, 4],
-        OuterLoopIndex=2,
-        OrientationReversed=False,
-    )
-
-
-@pytest.fixture()
-def brep_edge(interval):
-    return BrepEdge(
-        Curve3dIndex=2,
-        TrimIndices=[4, 5, 6, 7],
-        StartIndex=2,
-        EndIndex=6,
-        ProxyCurveIsReversed=True,
-        Domain=interval,
-    )
-
-
-@pytest.fixture()
-def brep_loop():
-    return BrepLoop(FaceIndex=5, TrimIndices=[3, 4, 5], Type="unknown")
-
-
-@pytest.fixture()
-def brep_trim():
-    return BrepTrim(
-        EdgeIndex=3,
-        StartIndex=4,
-        EndIndex=6,
-        FaceIndex=1,
-        LoopIndex=4,
-        CurveIndex=7,
-        IsoStatus=6,
-        TrimType="Mated",
-        IsReversed=False,
-        # These attributes are not handled in C#
-        # Domain=None,
-    )
-
-
-@pytest.fixture
-def brep(
-    mesh,
-    box,
-    surface,
-    curve,
-    polyline,
-    circle,
-    point,
-    brep_edge,
-    brep_loop,
-    brep_trim,
-    brep_face,
-):
-    return Brep(
-        provenance="pytest",
-        bbox=box,
-        area=32,
-        volume=54,
-        displayValue=mesh,
-        Surfaces=[surface, surface, surface],
-        Curve3D=[curve, polyline],
-        Curve2D=[circle],
-        Vertices=[point, point, point, point],
-        Edges=[brep_edge],
-        Loops=[brep_loop, brep_loop],
-        Trims=[brep_trim],
-        Faces=[brep_face, brep_face],
-        IsClosed=False,
-        Orientation=3,
-    )
-
-
-@pytest.fixture
-def geometry_objects_dict(
-    point,
-    vector,
-    plane,
-    line,
-    arc,
-    circle,
-    ellipse,
-    polyline,
-    curve,
-    polycurve,
-    surface,
-    brep_trim,
-):
-    return {
-        "point": point,
-        "vector": vector,
-        "plane": plane,
-        "line": line,
-        "arc": arc,
-        "circle": circle,
-        "ellipse": ellipse,
-        "polyline": polyline,
-        "curve": curve,
-        "polycurve": polycurve,
-        "surface": surface,
-        "brep_trim": brep_trim,
-    }
-
-
-@pytest.mark.parametrize(
-    "object_name",
-    [
-        "point",
-        "vector",
-        "plane",
-        "line",
-        "arc",
-        "circle",
-        "ellipse",
-        "polyline",
-        "curve",
-        "polycurve",
-        "surface",
-        "brep_trim",
-    ],
-)
-def test_to_and_from_list(object_name: str, geometry_objects_dict):
-    object = geometry_objects_dict[object_name]
-    assert hasattr(object, "to_list")
-    assert hasattr(object, "from_list")
-
-    chunks = object.to_list()
-    assert isinstance(chunks, list)
-
-    object_class = object.__class__
-    decoded_object: Base = object_class.from_list(chunks)
-    assert decoded_object.get_id() == object.get_id()
-
-
-def test_brep_surfaces_value_serialization(surface):
-    brep = Brep()
-    assert brep.Surfaces == None
-    assert brep.SurfacesValue == None
-    brep.Surfaces = [surface, surface]
-    assert brep.SurfacesValue == ObjectArray.from_objects([surface, surface]).data
-
-    brep.SurfacesValue = ObjectArray.from_objects([surface]).data
-    assert len(brep.Surfaces) == 1
-    assert brep.Surfaces[0].get_id() == surface.get_id()
-
-
-def test_brep_curve2d_values_serialization(curve, polyline, circle):
-    brep = Brep()
-    assert brep.Curve2D == None
-    assert brep.Curve2DValues == None
-    brep.Curve2D = [curve, polyline]
-    assert brep.Curve2DValues == CurveArray.from_curves([curve, polyline]).data
-
-    brep.Curve2DValues = CurveArray.from_curves([circle]).data
-    assert len(brep.Curve2D) == 1
-    assert brep.Curve2D[0].get_id() == circle.get_id()
-
-
-def test_brep_curve3d_values_serialization(curve, polyline, circle):
-    brep = Brep()
-    assert brep.Curve3D == None
-    assert brep.Curve3DValues == None
-    brep.Curve3D = [curve, polyline]
-    assert brep.Curve3DValues == CurveArray.from_curves([curve, polyline]).data
-
-    brep.Curve3DValues = CurveArray.from_curves([circle]).data
-    assert len(brep.Curve3D) == 1
-    assert brep.Curve3D[0].get_id() == circle.get_id()
-
-
-def test_brep_vertices_values_serialization():
-    brep = Brep()
-    brep.VerticesValue = [1, 1, 1, 1, 2, 2, 2, 3, 3, 3]
-    brep.Vertices[0].get_id() == Point(x=1, y=1, z=1, _units="mm").get_id()
-    brep.Vertices[1].get_id() == Point(x=2, y=2, z=2, _units="mm").get_id()
-    brep.Vertices[2].get_id() == Point(x=3, y=3, z=3, _units="mm").get_id()
-
-
-def test_trims_value_serialization():
-    brep = Brep()
-    brep.TrimsValue = [
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        1,
-        1,
-        1,
-        1,
-        0,
-        0,
-        0,
-        0,
-        1,
-        2,
-        1,
-        0,
-    ]
-
-    brep.Trims[0].get_id() == BrepTrim(
-        EdgeIndex=0,
-        StartIndex=0,
-        EndIndex=0,
-        FaceIndex=0,
-        LoopIndex=0,
-        CurveIndex=0,
-        IsoStatus=1,
-        TrimType=BrepTrimTypeEnum.Boundary,
-        IsReversed=False,
-    ).get_id()
-
-    brep.Trims[1].get_id() == BrepTrim(
-        EdgeIndex=1,
-        StartIndex=0,
-        EndIndex=0,
-        FaceIndex=0,
-        LoopIndex=0,
-        CurveIndex=1,
-        IsoStatus=2,
-        TrimType=BrepTrimTypeEnum.Boundary,
-        IsReversed=True,
-    ).get_id()
-
-
-def test_serialized_brep_attributes(brep: Brep):
-    transport = MemoryTransport()
-    serialized = operations.serialize(brep, [transport])
-    serialized_dict = json.loads(serialized)
-
-    removed_keys = ["Surfaces", "Curve3D", "Curve2D", "Vertices", "Trims"]
-
-    for k in removed_keys:
-        assert k not in serialized_dict.keys()

tests/test_objects.py

@@ -1,9 +1,9 @@
-import pytest
-from specklepy.api.models import Stream
-from specklepy.objects import Base
-from specklepy.objects.encoding import ObjectArray
-from specklepy.serialization.base_object_serializer import BaseObjectSerializer
 from specklepy.transports.sqlite import SQLiteTransport
+from specklepy.objects import Base
+from specklepy.transports.memory import MemoryTransport
+from specklepy.api.models import Stream
+from specklepy.serialization.base_object_serializer import BaseObjectSerializer
+import pytest
 
 
 class TestObject:
@@ -38,9 +38,3 @@ class TestObject:
         assert fetched_base.name == base.name
         assert isinstance(fetched_base.vertices, list)
         # assert fetched_base["@detach"]["speckle_type"] == "reference"
-
-    def test_object_array_decoder(self):
-        array = ObjectArray()
-        array.data = [5, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 3, 1, 1, 1, 2, 1, 1, 1, 1]
-
-        assert array.decode(decoder=sum) == [5, 4, 3, 2, 1]

tests/test_serialization.py

@@ -1,4 +1,5 @@
 import json
+from attr import has
 import pytest
 from specklepy.api import operations
 from specklepy.transports.server import ServerTransport
@@ -52,11 +53,6 @@ class TestSerialization:
     def test_send_and_receive(self, client, sample_stream, mesh):
         transport = ServerTransport(client=client, stream_id=sample_stream.id)
         hash = operations.send(mesh, transports=[transport])
-
-        # also try constructing server transport with token and url
-        transport = ServerTransport(
-            stream_id=sample_stream.id, token=client.me["token"], url=client.url
-        )
         # use a fresh memory transport to force receiving from remote
         received = operations.receive(
             hash, remote_transport=transport, local_transport=MemoryTransport()
@@ -88,4 +84,4 @@ class TestSerialization:
         untyped = '{"foo": "bar"}'
         deserialised = operations.deserialize(untyped)
 
-        assert deserialised == {"foo": "bar"}
+        assert deserialised == {"foo": "bar"}

tests/test_transforms.py

@@ -1,151 +0,0 @@
-from typing import List
-import pytest
-from specklepy.api import operations
-from specklepy.objects.geometry import Mesh, Point, Vector
-from specklepy.objects.other import (
-    Transform,
-    BlockInstance,
-    BlockDefinition,
-    IDENTITY_TRANSFORM,
-)
-
-
-@pytest.fixture()
-def point():
-    return Point(x=1, y=10, z=2)
-
-
-@pytest.fixture()
-def points():
-    return [Point(x=1 + i, y=10 + i, z=2 + i) for i in range(5)]
-
-
-@pytest.fixture()
-def point_value():
-    return [1, 10, 2]
-
-
-@pytest.fixture()
-def points_values():
-    coords = []
-    for i in range(5):
-        coords.extend([1 + i, 10 + i, 2 + 1])
-    return coords
-
-
-@pytest.fixture()
-def vector():
-    return Vector(x=1, y=10, z=2)
-
-
-@pytest.fixture()
-def vector_value():
-    return [1, 1, 2]
-
-
-@pytest.fixture()
-def mesh():
-    return Mesh(
-        vertices=[-7, 5, 1, -8, 4, 0, -7, 3, 0, -6, 4, 0],
-        faces=[1, 1, 2, 3, 0],
-        units="feet",
-    )
-
-
-@pytest.fixture()
-def transform():
-    """Translates to [1, 2, 0] and scales z by 0.5"""
-    return Transform.from_list(
-        [
-            1.0,
-            0.0,
-            0.0,
-            1.0,
-            0.0,
-            1.0,
-            0.0,
-            2.0,
-            0.0,
-            0.0,
-            0.5,
-            0.0,
-            0.0,
-            0.0,
-            0.0,
-            1.0,
-        ]
-    )
-
-
-def test_point_transform(point: Point, transform: Transform):
-    new_point = transform.apply_to_point(point)
-
-    assert new_point.x == point.x + 1
-    assert new_point.y == point.y + 2
-    assert new_point.z == point.z * 0.5
-
-
-def test_points_transform(points: List[Point], transform: Transform):
-    new_points = transform.apply_to_points(points)
-
-    for (i, new_point) in enumerate(new_points):
-        assert new_point.x == points[i].x + 1
-        assert new_point.y == points[i].y + 2
-        assert new_point.z == points[i].z * 0.5
-
-
-def test_point_value_transform(point_value: List[float], transform: Transform):
-    new_coords = transform.apply_to_point_value(point_value)
-
-    assert new_coords[0] == point_value[0] + 1
-    assert new_coords[1] == point_value[1] + 2
-    assert new_coords[2] == point_value[2] * 0.5
-
-
-def test_points_values_transform(points_values: List[float], transform: Transform):
-    new_coords = transform.apply_to_points_values(points_values)
-
-    for i in range(0, len(points_values), 3):
-        assert new_coords[i] == points_values[i] + 1
-        assert new_coords[i + 1] == points_values[i + 1] + 2
-        assert new_coords[i + 2] == points_values[i + 2] * 0.5
-
-
-def test_vector_transform(vector: Vector, transform: Transform):
-    new_vector = transform.apply_to_vector(vector)
-
-    assert new_vector.x == vector.x
-    assert new_vector.y == vector.y
-    assert new_vector.z == vector.z * 0.5
-
-
-def test_vector_value_transform(vector_value: List[float], transform: Transform):
-    new_coords = transform.apply_to_vector_value(vector_value)
-
-    assert new_coords[0] == vector_value[0]
-    assert new_coords[1] == vector_value[1]
-    assert new_coords[2] == vector_value[2] * 0.5
-
-
-def test_transform_fails_with_malformed_value():
-    with pytest.raises(ValueError):
-        Transform.from_list("asdf")
-    with pytest.raises(ValueError):
-        Transform.from_list([7, 8, 9])
-
-
-def test_transform_serialisation(transform: Transform):
-    serialized = operations.serialize(transform)
-    deserialized = operations.deserialize(serialized)
-
-    assert transform.get_id() == deserialized.get_id()
-
-
-def test_mesh_transform(mesh: Mesh, transform: Transform):
-    new_mesh = mesh.transform_to(transform)
-
-    assert mesh.vertices != new_mesh.vertices
-
-    new_mesh.vertices = mesh.vertices
-
-    assert mesh.get_id() == new_mesh.get_id()

tests/test_wrapper.py

@@ -18,14 +18,6 @@ class TestWrapper:
         assert wacky_wrap.branch_name == "🍕⬅🌟 you wat?"
         assert wrap.type == "branch"
 
-    def test_parse_nested_branch(self):
-        wrap = StreamWrapper(
-            "https://testing.speckle.dev/streams/4c3ce1459c/branches/izzy/dev"
-        )
-
-        assert wrap.branch_name == "izzy/dev"
-        assert wrap.type == "branch"
-
     def test_parse_commit(self):
         wrap = StreamWrapper(
             "https://testing.speckle.dev/streams/4c3ce1459c/commits/8b9b831792"
@@ -47,33 +39,3 @@ class TestWrapper:
             "https://testing.speckle.dev/streams/0c6ad366c4/globals/abd3787893"
         )
         assert wrap.type == "commit"
-
-    #! NOTE: the following three tests may not pass locally if you have a `speckle.xyz` account in manager
-    def test_get_client_without_auth(self):
-        wrap = StreamWrapper(
-            "https://speckle.xyz/streams/4c3ce1459c/commits/8b9b831792"
-        )
-        client = wrap.get_client()
-
-        assert client is not None
-
-    def test_get_new_client_with_token(self):
-        wrap = StreamWrapper(
-            "https://speckle.xyz/streams/4c3ce1459c/commits/8b9b831792"
-        )
-        client = wrap.get_client()
-        client = wrap.get_client(token="super-secret-token")
-
-        assert client.me["token"] == "super-secret-token"
-
-    def test_get_transport_with_token(self):
-        wrap = StreamWrapper(
-            "https://speckle.xyz/streams/4c3ce1459c/commits/8b9b831792"
-        )
-        client = wrap.get_client()
-        assert not client.me  # unauthenticated bc no local accounts
-
-        transport = wrap.get_transport(token="super-secret-token")
-
-        assert transport is not None
-        assert client.me["token"] == "super-secret-token"