chore: bump version to 2.2.5

fix(sqlite): delay and try except transport init

README.md

@@ -45,7 +45,7 @@ from specklepy.api.credentials import get_default_account, get_local_accounts
 all_accounts = get_local_accounts() # get back a list
 account = get_default_account()
 
-client = SpeckleClient(host="localhost:3000", use_ssl=False)
+client = SpeckleClient(host="speckle.xyz")
 # client = SpeckleClient(host="yourserver.com") or whatever your host is
 
 client.authenticate(account.token)

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "specklepy"
-version = "2.2.3"
+version = "2.2.5"
 description = "The Python SDK for Speckle 2.0"
 readme = "README.md"
 authors = ["Speckle Systems <devops@speckle.systems>"]

specklepy/api/client.py

@@ -21,6 +21,33 @@ from gql.transport.websockets import WebsocketsTransport
 
 
 class SpeckleClient:
+    """
+    The `SpeckleClient` is your entry point for interacting with your Speckle Server's GraphQL API.
+    You'll need to have access to a server to use it, or you can use our public server `speckle.xyz`.
+
+    To authenticate the client, you'll need to have downloaded the [Speckle Manager](https://speckle.guide/#speckle-manager)
+    and added your account.
+
+    ```py
+    from specklepy.api.client import SpeckleClient
+    from specklepy.api.credentials import get_default_account
+
+    # initialise the client
+    client = SpeckleClient(host="speckle.xyz") # or whatever your host is
+    # client = SpeckleClient(host="localhost:3000", use_ssl=False) or use local server
+
+    # authenticate the client with a token (account has been added in Speckle Manager)
+    account = get_default_account()
+    client.authenticate(token=account.token)
+
+    # create a new stream. this returns the stream id
+    new_stream_id = client.stream.create(name="a shiny new stream")
+
+    # use that stream id to get the stream from the server
+    new_stream = client.stream.get(id=new_stream_id)
+    ```
+    """
+
     DEFAULT_HOST = "speckle.xyz"
     USE_SSL = True
 

specklepy/api/operations.py

@@ -52,7 +52,8 @@ def receive(
     Arguments:
         obj_id {str} -- the id of the object to receive
         remote_transport {Transport} -- the transport to receive from
-        local_transport {Transport} -- the transport to send from
+        local_transport {Transport} -- the local cache to check for existing objects
+                                       (defaults to `SQLiteTransport`)
 
     Returns:
         Base -- the base object
@@ -97,9 +98,7 @@ def serialize(base: Base, write_transports: List[AbstractTransport] = []) -> str
     return serializer.write_json(base)[1]
 
 
-def deserialize(
-    obj_string: str, read_transport: AbstractTransport = SQLiteTransport()
-) -> Base:
+def deserialize(obj_string: str, read_transport: AbstractTransport = None) -> Base:
     """
     Deserialize a string object into a Base object. If the object contains referenced child objects that are not stored in the local db, a read transport needs to be provided in order to recompose the base with the children objects.
 
@@ -111,6 +110,9 @@ def deserialize(
     Returns:
         Base -- the deserialized object
     """
+    if not read_transport:
+        read_transport = SQLiteTransport()
+
     serializer = BaseObjectSerializer(read_transport=read_transport)
 
     return serializer.read_json(obj_string=obj_string)

specklepy/objects/base.py

@@ -98,7 +98,7 @@ class Base(_RegisteringBase):
     @classmethod
     def validate_prop_name(cls, name: str) -> None:
         """Validator for dynamic attribute names."""
-        if name in ("", "@"):
+        if name in {"", "@"}:
             raise ValueError("Invalid Name: Base member names cannot be empty strings")
         if name.startswith("@@"):
             raise ValueError(
@@ -172,7 +172,7 @@ class Base(_RegisteringBase):
             if not name.startswith("_")
             and name
             != "fields"  # soon to be removed as this pydantic prop is depreciated
-            and isinstance(getattr(self, name, None), property)
+            and isinstance(getattr(type(self), name, None), property)
         ]
         return attrs + properties
 
@@ -215,15 +215,11 @@ class Base(_RegisteringBase):
             return 0
         parsed.append(base)
 
-        count = 0
-
-        for name, value in base.__dict__.items():
-            if name.startswith("@"):
-                continue
-            else:
-                count += self._handle_object_count(value, parsed)
-
-        return count
+        return sum(
+            self._handle_object_count(value, parsed)
+            for name, value in base.__dict__.items()
+            if not name.startswith("@")
+        )
 
     def _handle_object_count(self, obj: Any, parsed: List) -> int:
         count = 0

specklepy/objects/units.py

@@ -6,6 +6,7 @@ UNITS_STRINGS = {
     "mm": ["mm", "mil", "millimeters", "millimetres"],
     "cm": ["cm", "centimetre", "centimeter", "centimetres", "centimeters"],
     "m": ["m", "meter", "meters", "metre", "metres"],
+    "km": ["km", "kilometer", "kilometre", "kilometers", "kilometres"],
     "in": ["in", "inch", "inches"],
     "ft": ["ft", "foot", "feet"],
     "yd": ["yd", "yard", "yards"],

specklepy/transports/sqlite.py

@@ -6,7 +6,6 @@ import sqlite3
 from typing import Any, List, Dict
 from appdirs import user_data_dir
 from contextlib import closing
-from multiprocessing import Process, Queue
 from specklepy.transports.abstract_transport import AbstractTransport
 from specklepy.logging.exceptions import SpeckleException
 
@@ -19,7 +18,6 @@ class SQLiteTransport(AbstractTransport):
     _scheduler = sched.scheduler(time.time, time.sleep)
     _polling_interval = 0.5  # seconds
     __connection: sqlite3.Connection = None
-    __queue: Queue = Queue()
     app_name: str = ""
     scope: str = ""
     saved_obj_count: int = 0
@@ -36,12 +34,18 @@ class SQLiteTransport(AbstractTransport):
         self.scope = scope or "Objects"
         self._base_path = base_path or self.__get_base_path()
 
-        os.makedirs(self._base_path, exist_ok=True)
+        try:
+            os.makedirs(self._base_path, exist_ok=True)
 
-        self._root_path = os.path.join(
-            os.path.join(self._base_path, f"{self.scope}.db")
-        )
-        self.__initialise()
+            self._root_path = os.path.join(
+                os.path.join(self._base_path, f"{self.scope}.db")
+            )
+            self.__initialise()
+        except Exception as ex:
+            raise SpeckleException(
+                f"SQLiteTransport could not initialise {self.scope}.db at {self._base_path}. Either provide a different `base_path` or use an alternative transport.",
+                ex,
+            )
 
     def __repr__(self) -> str:
         return f"SQLiteTransport(app: '{self.app_name}', scope: '{self.scope}')"
@@ -63,26 +67,26 @@ class SQLiteTransport(AbstractTransport):
             if os_name.startswith("Mac"):
                 system = "darwin"
 
-        if system == "darwin":
-            path = os.path.expanduser("~/.config/")
-            return os.path.join(path, self.app_name)
-        else:
+        if system != "darwin":
             return user_data_dir(appname=self.app_name, appauthor=False, roaming=True)
 
-    def __consume_queue(self):
-        if self._is_writing or self.__queue.empty():
-            return
-        print("CONSUME QUEUE")
-        self._is_writing = True
-        while not self.__queue.empty():
-            data = self.__queue.get()
-            self.save_object(data[0], data[1])
-        self._is_writing = False
+        path = os.path.expanduser("~/.config/")
+        return os.path.join(path, self.app_name)
 
-        self._scheduler.enter(
-            delay=self._polling_interval, priority=1, action=self.__consume_queue
-        )
-        self._scheduler.run(blocking=True)
+    # def __consume_queue(self):
+    #     if self._is_writing or self.__queue.empty():
+    #         return
+    #     print("CONSUME QUEUE")
+    #     self._is_writing = True
+    #     while not self.__queue.empty():
+    #         data = self.__queue.get()
+    #         self.save_object(data[0], data[1])
+    #     self._is_writing = False
+
+    #     self._scheduler.enter(
+    #         delay=self._polling_interval, priority=1, action=self.__consume_queue
+    #     )
+    #     self._scheduler.run(blocking=True)
 
     # def save_object(self, id: str, serialized_object: str) -> None:
     #     """Adds an object to the queue and schedules it to be saved.
@@ -102,15 +106,14 @@ class SQLiteTransport(AbstractTransport):
     def save_object_from_transport(
         self, id: str, source_transport: AbstractTransport
     ) -> None:
-        """Adds an object from the given transport to the queue and schedules it to be saved.
+        """Adds an object from the given transport to the the local db
 
         Arguments:
             id {str} -- the object id
             source_transport {AbstractTransport) -- the transport through which the object can be found
         """
         serialized_object = source_transport.get_object(id)
-        self.__queue.put((id, serialized_object))
-        raise NotImplementedError
+        self.save_object(id, serialized_object)
 
     def save_object(self, id: str, serialized_object: str) -> None:
         """Directly saves an object into the database.