feat(objects): add value property to points

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="speckle.xyz")
+client = SpeckleClient(host="localhost:3000", use_ssl=False)
 # 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.5"
+version = "2.2.3"
 description = "The Python SDK for Speckle 2.0"
 readme = "README.md"
 authors = ["Speckle Systems <devops@speckle.systems>"]

specklepy/api/client.py

@@ -21,33 +21,6 @@ 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,8 +52,7 @@ 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 local cache to check for existing objects
-                                       (defaults to `SQLiteTransport`)
+        local_transport {Transport} -- the transport to send from
 
     Returns:
         Base -- the base object
@@ -98,7 +97,9 @@ def serialize(base: Base, write_transports: List[AbstractTransport] = []) -> str
     return serializer.write_json(base)[1]
 
 
-def deserialize(obj_string: str, read_transport: AbstractTransport = None) -> Base:
+def deserialize(
+    obj_string: str, read_transport: AbstractTransport = SQLiteTransport()
+) -> 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.
 
@@ -110,9 +111,6 @@ def deserialize(obj_string: str, read_transport: AbstractTransport = None) -> Ba
     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(type(self), name, None), property)
+            and isinstance(getattr(self, name, None), property)
         ]
         return attrs + properties
 
@@ -215,11 +215,15 @@ class Base(_RegisteringBase):
             return 0
         parsed.append(base)
 
-        return sum(
-            self._handle_object_count(value, parsed)
-            for name, value in base.__dict__.items()
-            if not name.startswith("@")
-        )
+        count = 0
+
+        for name, value in base.__dict__.items():
+            if name.startswith("@"):
+                continue
+            else:
+                count += self._handle_object_count(value, parsed)
+
+        return count
 
     def _handle_object_count(self, obj: Any, parsed: List) -> int:
         count = 0

specklepy/objects/geometry.py

@@ -24,6 +24,10 @@ class Point(Base, speckle_type=GEOMETRY + "Point"):
     def __repr__(self) -> str:
         return f"{self.__class__.__name__}(x: {self.x}, y: {self.y}, z: {self.z}, id: {self.id}, speckle_type: {self.speckle_type})"
 
+    @property
+    def value(self) -> List[float]:
+        return [self.x, self.y, self.z]
+
 
 class Vector(Point, speckle_type=GEOMETRY + "Vector"):
     pass

specklepy/objects/units.py

@@ -6,7 +6,6 @@ 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,6 +6,7 @@ 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
 
@@ -18,6 +19,7 @@ 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
@@ -34,18 +36,12 @@ class SQLiteTransport(AbstractTransport):
         self.scope = scope or "Objects"
         self._base_path = base_path or self.__get_base_path()
 
-        try:
-            os.makedirs(self._base_path, exist_ok=True)
+        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()
-        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,
-            )
+        self._root_path = os.path.join(
+            os.path.join(self._base_path, f"{self.scope}.db")
+        )
+        self.__initialise()
 
     def __repr__(self) -> str:
         return f"SQLiteTransport(app: '{self.app_name}', scope: '{self.scope}')"
@@ -67,26 +63,26 @@ class SQLiteTransport(AbstractTransport):
             if os_name.startswith("Mac"):
                 system = "darwin"
 
-        if system != "darwin":
+        if system == "darwin":
+            path = os.path.expanduser("~/.config/")
+            return os.path.join(path, self.app_name)
+        else:
             return user_data_dir(appname=self.app_name, appauthor=False, roaming=True)
 
-        path = os.path.expanduser("~/.config/")
-        return os.path.join(path, self.app_name)
+    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
 
-    # 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)
+        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.
@@ -106,14 +102,15 @@ class SQLiteTransport(AbstractTransport):
     def save_object_from_transport(
         self, id: str, source_transport: AbstractTransport
     ) -> None:
-        """Adds an object from the given transport to the the local db
+        """Adds an object from the given transport to the queue and schedules it to be saved.
 
         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.save_object(id, serialized_object)
+        self.__queue.put((id, serialized_object))
+        raise NotImplementedError
 
     def save_object(self, id: str, serialized_object: str) -> None:
         """Directly saves an object into the database.