Merge branch 'speckle' into main

Author: Licini

src/compas_cloud/proxy.py

@@ -92,7 +92,7 @@ class Proxy():
 
     """
 
-    def __init__(self, host='127.0.0.1', port=9009, background=True, errorHandler=None, once=True, start_server=True):
+    def __init__(self, host='127.0.0.1', port=9009, background=True, errorHandler=None, once=True, start_server=True, speckle={}):
         """init function that starts a remote server then assigns corresponding client(websockets/.net) to the proxy"""
         self._python = compas._os.select_python(None)
         self.host = host
@@ -112,6 +112,9 @@ def __init__(self, host='127.0.0.1', port=9009, background=True, errorHandler=No
 
         self.callbacks = {}
         self.errorHandler = errorHandler
+        if speckle:
+            result = self.speckle_connect(host=speckle['host'], token=speckle['token'])
+            print(result)
 
     def package(self, function, cache=False):
         raise RuntimeError("Proxy.package() has been deprecated, please use Proxy.function() instead.")
@@ -296,7 +299,15 @@ def check(self):
     def once(self):
         """Set the server to close once this client disconnet"""
         return self.send({'control': 'once'})
+    
+    def speckle_connect(self, host="speckle.xyz", token=None):
+        return self.send({"speckle": {"connect": {"host": host, "token": token}}})
 
+    def speckle_push(self, stream_id, item):
+        return self.send({"speckle": {"update": {"stream_id": stream_id, "item": item}}})
+
+    def speckle_pull(self, stream_id):
+        return self.send({"speckle": {"get": {"stream_id": stream_id}}})
 
 class Sessions_client():
 

src/compas_cloud/server.py

@@ -8,6 +8,7 @@
 import sys
 import traceback
 import pkg_resources
+from compas_cloud.speckle import Speckle
 
 try:
     from compas.data import DataEncoder
@@ -22,6 +23,7 @@ class CompasServerProtocol(WebSocketServerProtocol):
     cached = {}
     sessions = None
     server_type = "NORMAL"
+    speckle = Speckle()
 
     def onConnect(self, request):
         """print client info on connection"""
@@ -178,6 +180,9 @@ def process(self, data):
             if 'version' in data:
                 result = self.version()
 
+            if 'speckle' in data:
+                result = self.speckle.process_command(data['speckle'])
+
         except BaseException as error:
 
             if isinstance(error, KeyboardInterrupt):

src/compas_cloud/speckle/__init__.py

@@ -0,0 +1 @@
+from .speckle import Speckle

src/compas_cloud/speckle/data.py

@@ -0,0 +1,13 @@
+from specklepy.objects import Base
+from compas.data import json_dumps
+import json
+
+
+class Data(Base):
+    data = dict
+
+    def __init__(self, data={}, stream_id=None, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.data = json.loads(json_dumps(data))
+        if stream_id:
+            self.data['stream_id'] = stream_id

src/compas_cloud/speckle/speckle.py

@@ -0,0 +1,73 @@
+try:
+    import specklepy
+    from specklepy.api.client import SpeckleClient
+    from specklepy.api.credentials import get_account_from_token
+    from specklepy.transports.server import ServerTransport
+    from specklepy.api import operations
+    from compas_cloud.speckle.data import Data as SpeckleData
+except ImportError:
+    specklepy = None
+
+from compas.data import json_loads
+import json
+
+
+class Speckle():
+
+    def process_command(self, command):
+        if 'connect' in command:
+            return self.connect(host=command['connect']['host'], token=command['connect']['token'])
+        if 'get' in command:
+            return self.get_item(command['get']['stream_id'])
+        if 'update' in command:
+            return self.update_item(command['update']['item'], stream_id=command['update']['stream_id'])
+        else:
+            return "Command not found"
+
+    def connect(self, host="speckle.xyz", token=None):
+        if not specklepy:
+            raise ImportError("Specklepy is not installed")
+        print("Connecting to {} with {}".format(host, token))
+        self.client = SpeckleClient(host=host)
+        account = get_account_from_token(token, host)
+        self.client.authenticate_with_account(account)
+        return "Connected to {} with {}".format(host, token)
+
+    def update_item(self, item, stream_id=None, name=None, message=None):
+        # Create new stream if stream_id is None
+        if not stream_id:
+            stream_id = self.client.stream.create(name=name)
+        transport = ServerTransport(client=self.client, stream_id=stream_id)
+        hash = operations.send(base=SpeckleData(item, stream_id), transports=[transport])
+        self.client.commit.create(
+            stream_id=stream_id,
+            object_id=hash,
+            message=message,
+        )
+        return stream_id
+
+    def get_item(self, stream_id):
+        stream = self.client.stream.get(id=stream_id)
+        transport = ServerTransport(client=self.client, stream_id=stream_id)
+        latest_commit = stream.branches.items[0].commits.items[0]
+        received_base = operations.receive(obj_id=latest_commit.referencedObject, remote_transport=transport)
+        data = received_base.data
+        return json_loads(json.dumps(data))
+
+
+if __name__ == "__main__":
+
+    import compas
+    from compas.datastructures import Mesh
+
+    client = Speckle()
+    client.connect(token="4b6a06f4c7b114e3b4115e1bba5536261cb4d3bf20")
+
+    stream_id = "c0538fd521"
+    mesh = Mesh.from_obj(compas.get('faces.obj'))
+    stream_id = client.update_item(mesh, name="faces", stream_id=stream_id)
+    print(stream_id)
+
+    # stream_id = "c0538fd521"
+    # item = client.get_item(stream_id)
+    # print(item)

temp/speckle.py

@@ -0,0 +1,15 @@
+import compas
+from compas.datastructures import Mesh
+
+from compas_cloud.proxy import Proxy
+
+p = Proxy()
+result = p.send({"speckle": {"connect": {"host": "speckle.xyz", "token": "4b6a06f4c7b114e3b4115e1bba5536261cb4d3bf20"}}})
+print("check", result)
+
+mesh = Mesh.from_obj(compas.get('faces.obj'))
+# mesh = Mesh.from_off(compas.get('tubemesh.off'))
+
+
+mesh = p.send({"speckle": {"update": {"stream_id": "c0538fd521", "item": mesh}}})
+print(mesh)

temp/test.py

@@ -0,0 +1,4 @@
+from compas_cloud.proxy import Proxy
+
+p = Proxy(speckle={"host": "speckle.xyz", "token": "__YOUR_TOKEN__"})
+p.speckle.watch([stream1, stream2, stream3])