Update Readme.md

Kate/2.9 debugging

patch_version.py

@@ -5,17 +5,18 @@ def patch_installer(tag):
     """Patches the installer with the correct connector version and specklepy version"""
     iss_file = "speckle-sharp-ci-tools/arcgis.iss"
     setup_whl_file = "setup.py"
+    conda_file = "speckle_arcgis_installer/conda_clone_activate.py"
     toolbox_install_file = "speckle_arcgis_installer/toolbox_install.py"
+    toolbox_manual_install_file = "speckle_arcgis_installer/toolbox_install_manual.py"
 
     #py_tag = get_specklepy_version()
     with open(iss_file, "r") as file:
         lines = file.readlines()
-        if "#define AppVersion" in lines[12]: lines[12] = f'#define AppVersion "{tag.split("-")[0]}"\n'
-        else: lines.insert(12, f'#define AppVersion "{tag.split("-")[0]}"\n')
-
-        if "#define AppInfoVersion" in lines[13]: lines[13] = f'#define AppInfoVersion "{tag}"\n'
-        else: lines.insert(13, f'#define AppInfoVersion "{tag}"\n')
-
+        for i, line in enumerate(lines):
+            if "#define AppVersion " in line: 
+                lines[i] = f'#define AppVersion "{tag.split("-")[0]}"\n'
+            if "#define AppInfoVersion " in line: 
+                lines[i] = f'#define AppInfoVersion "{tag}"\n'
         with open(iss_file, "w") as file:
             file.writelines(lines)
             print(f"Patched installer with connector v{tag} and specklepy ")
@@ -23,27 +24,33 @@ def patch_installer(tag):
 
     with open(setup_whl_file, "r") as file:
         lines = file.readlines()
-        if "version=" in lines[17]: lines[17] = f'\t\t\tversion="{tag.split("-")[0]}",\n'
-        else: lines.insert(17, f'\t\t\tversion="{tag.split("-")[0]}",\n')
-        
+        for i, line in enumerate(lines):
+            if "version=" in line: 
+                lines[i] = f'\t\t\tversion="{tag.split("-")[0]}",\n'
+                break
         with open(setup_whl_file, "w") as file:
             file.writelines(lines)
             print(f"Patched whl setup with connector v{tag} and specklepy ")
     file.close()
 
-    with open(toolbox_install_file, "r") as file:
-        lines = file.readlines()
-        for i, line in enumerate(lines):
-            if "-py3-none-any.whl" in line: 
-                p1 = line.split("-py3-none-any.whl")[0].split("-")[0]
-                p2 = f'{tag.split("-")[0]}'
-                p3 = line.split("-py3-none-any.whl")[1]
-                lines[i] = p1+"-"+p2+"-py3-none-any.whl"+p3
-        with open(toolbox_install_file, "w") as file:
-            file.writelines(lines)
-            print(f"Patched toolbox_installer with connector v{tag} and specklepy ")
-        
-    file.close()
+    def whlFileRename(fileName: str): 
+        with open(fileName, "r") as file:
+            lines = file.readlines()
+            for i, line in enumerate(lines):
+                if "-py3-none-any.whl" in line: 
+                    p1 = line.split("-py3-none-any.whl")[0].split("-")[0]
+                    p2 = f'{tag.split("-")[0]}'
+                    p3 = line.split("-py3-none-any.whl")[1]
+                    lines[i] = p1+"-"+p2+"-py3-none-any.whl"+p3
+            with open(fileName, "w") as file:
+                file.writelines(lines)
+                print(f"Patched toolbox_installer with connector v{tag} and specklepy ")
+        file.close()
+
+    whlFileRename(conda_file)
+    whlFileRename(toolbox_install_file)
+    whlFileRename(toolbox_manual_install_file)
+
 
 def main():
     if len(sys.argv) < 2:

setup.py

@@ -1,7 +1,7 @@
 # to build an installer: run cmd from this folder or use terminal: "%PROGRAMFILES%\\ArcGIS\\Pro\\bin\\Python\\envs\\arcgispro-py3\\python.exe" 
 # 
 # 1) python patch_version.py 2.x.x 
-# 2) (if needed: pip install wheel) python setup.py sdist bdist_wheel   #C:\\Users\\username\\Documents\\00_Speckle\\GitHub\\speckle-arcgis\\setup.py sdist bdist_wheel 
+# 2) python setup.py sdist bdist_wheel   #C:\\Users\\username\\Documents\\00_Speckle\\GitHub\\speckle-arcgis\\setup.py sdist bdist_wheel 
 # copy .whl from "dist" to "speckle_arcgis_installer" 
 
 # ref: https://pro.arcgis.com/en/pro-app/2.8/arcpy/geoprocessing_and_python/distributing-python-modules.htm
@@ -15,7 +15,7 @@ def read(fname):
  
 setup(name='speckle_toolbox', 
       author='SpeckleSystems',
-			version="2.9.3",
+			version="2.9.4",
       description=("Example for extending geoprocessing through Python modules"),
       long_description=read('Readme.md'),
       python_requires='~=3.3',

speckle_arcgis_installer/Readme.md

@@ -0,0 +1,13 @@
+### Manual installation
+
+1. Download present "speckle_arcgis_installer" folder
+2. Clone the default ArcGIS Pro conda environment and restart ArcGIS Pro
+       - for 2.9.0: Project-> Python-> Manage Environments-> Clone Default
+       - for 3.0.0: Project-> Package Manager-> Active Environment (Environment Manager)-> Clone arcgispro-py3
+3. Change the path to your new environemnt Python.exe if necessary (variable "pythonPath" in "toolbox_install_manual.py") 
+4. Enter the location of 'toolbox_install_manual.py' in the following command and run this command in ArcGIS Python console (View -> Python Window)
+
+```python
+import sysconfig; import subprocess; x = sysconfig.get_paths()['data'] + r"\python.exe"; subprocess.run((x, 'C:\\Users\\pathToFolder\\speckle_arcgis_installer\\toolbox_install_manual.py'), capture_output=True, text=True, shell=True, timeout=1000 )
+```
+

speckle_arcgis_installer/Speckle.pyt

@@ -0,0 +1 @@
+from speckle.speckle_arcgis import *

speckle_arcgis_installer/conda_clone_activate.py

@@ -8,50 +8,128 @@ import subprocess
 from subprocess import CalledProcessError
 from subprocess_call import subprocess_call
 
-from msilib.schema import Error
 import sys
 
-import arcpy 
-
 def setup():
-    #print(plugin_dir) 
     pythonExec = get_python_path() # import numpy; import os; print(os.path.abspath(numpy.__file__)) 
-    #print(pythonExec)
-    
-    if pythonExec is None: # env is default, need to restart ArcGIS
-        return False
+    return pythonExec # None if not successful 
     
 def get_python_path(): # create a full copy of default env 
+    #print("Get Python path")
     # or: import site; site.getsitepackages()[0]
     # import specklepy; import os; print(os.path.abspath(specklepy.__file__)) ##currentPythonExec = sysconfig.get_paths()['data'] + r"\python.exe"
 
     pythonExec = os.environ["ProgramFiles"] + r'\ArcGIS\Pro\bin\Python\envs\arcgispro-py3\python.exe' #(r"%PROGRAMFILES%\ArcGIS\Pro\bin\Python\envs\arcgispro-py3\python.exe") #os.path.dirname(sys.executable) + "\\python.exe" # default python.exe
     #print(pythonExec)
+    if not os.path.exists(pythonExec):
+        pythonExec = os.getenv('APPDATA').replace("Roaming", "Local") + r'\Programs\ArcGIS\Pro\bin\Python\envs\arcgispro-py3\python.exe'
+        if not os.path.exists(pythonExec): return None
+    #print(os.getenv('APPDATA') + r'\Programs\ArcGIS\Pro\bin\Python\envs\arcgispro-py3\python.exe')
+
     if sys.platform == "win32":
         env_new_name = "arcgispro-py3-speckle"
-        #clone_env(pythonExec, env_new_name) # only if doesn't exist yet 
+        newExec = clone_env(pythonExec, env_new_name) # only if doesn't exist yet 
+        if not os.path.exists(newExec): return None
+        
         activate_env(env_new_name)
-        return pythonExec
-    else: pass
+        return newExec
+    else: return None
 
 def clone_env(pythonExec_old: str, env_new_name: str): 
     install_folder = os.getenv('APPDATA').replace("\\Roaming","") + r"\Local\ESRI\conda\envs"   #r"%LOCALAPPDATA%\ESRI\conda\envs" 
-    #print("Clone default ArcGIS Pro conda env")
-    #print(install_folder)
-    #if not os.path.exists(install_folder): os.makedirs(install_folder)
+    if not os.path.exists(install_folder): os.makedirs(install_folder)
     
     default_env = pythonExec_old.replace("Pro\\bin\\Python\\envs\\arcgispro-py3\\python.exe","Pro\\bin\\Python\\envs\\arcgispro-py3") # + "\\" + 'arcgispro-py3'
     conda_exe = pythonExec_old.replace("Pro\\bin\\Python\\envs\\arcgispro-py3\\python.exe","Pro\\bin\\Python\\Scripts\\conda.exe") #%PROGRAMFILES%\ArcGIS\Pro\bin\Python\Scripts\conda.exe #base: %PROGRAMDATA%\Anaconda3\condabin\conda.bat
     new_env = install_folder + "\\" + env_new_name # %LOCALAPPDATA%\ESRI\conda\envs\...
 
-    subprocess_call( [ conda_exe, 'create', '--clone', default_env, '-p', new_env] ) # will not execute if already exists
+    if os.path.exists(conda_exe) and os.path.exists(default_env) and os.path.exists(new_env) and not os.path.exists(new_env + "\\python.exe"): 
+        # conda environment invalid: delete it's folder 
+        print(f"Removing invalid environment {new_env}")
+        os.remove(new_env)
 
+    if os.path.exists(conda_exe) and os.path.exists(default_env) and not os.path.exists(new_env): 
+        print("Wait for the default ArcGIS Pro conda environment to be cloned")
+        subprocess_call( [ conda_exe, 'config', '--set', 'ssl_verify', 'False'] )
+        subprocess_call( [ conda_exe, 'create', '--clone', default_env, '-p', new_env] ) # will not execute if already exists
+        subprocess_call( [ conda_exe, 'config', '--set', 'ssl_verify', 'True'] )
+
+    elif os.path.exists(new_env) and os.path.exists(new_env + "\\python.exe"):
+        print(f"Environment {new_env} already exists, preparing to install packages..")
+
+    print(new_env + "\\python.exe")
     return new_env + "\\python.exe"
 
 def activate_env(env_new_name: str):
     # using Popen, because process does not return result; subprocess.run will hang indefinitely 
     variable = subprocess.Popen((f'proswap {env_new_name}'),stdout = subprocess.PIPE,stderr = subprocess.PIPE,text = True,shell = True)
-    #print(variable) 
     # activate new env : https://support.esri.com/en/technical-article/000024206
 
-setup()
+
+def installToolbox(newExec: str):
+    print("Installing Speckle Toolbox")
+    whl_file = os.path.join(os.path.dirname(__file__), "speckle_toolbox-2.9.4-py3-none-any.whl" ) 
+    print(whl_file)
+    subprocess_call([newExec, '-m','pip','install','--upgrade', '--force-reinstall', whl_file])
+    # to uninstall: cmd.exe "C:\\Users\\username\\AppData\\Local\\ESRI\\conda\\envs\\arcgispro-2.9.4-py3-none-any.whl
+    return
+
+def installDependencies(pythonExec: str, pkgName: str, pkgVersion: str):
+    # install pip
+    print(pythonExec)
+    try:
+        import pip
+    except:
+        getPipFilePath = os.path.join(os.path.dirname(__file__), "get_pip.py") #TODO: give actual folder path 
+        exec(open(getPipFilePath).read())
+        # just in case the included version is old
+        subprocess_call([pythonExec, "-m", "pip", "install", "--upgrade", "pip"])
+        
+    # install package
+    try:
+        #import importlib #importlib.import_module(pkgName)
+        if pkgName == "specklepy":
+            import specklepy 
+            if pythonExec.replace("\\python.exe","") not in (os.path.abspath(specklepy.__file__)): 
+                print(f"Installing {pkgName} to {pythonExec}")
+                #subprocess_call( [pythonExec, "-m", "pip", "uninstall", f"{pkgName}"])
+                subprocess_call( [pythonExec, "-m", "pip", "install", f"{pkgName}=={pkgVersion}"])
+        elif pkgName == "panda3d":
+            import panda3d 
+            if pythonExec.replace("\\python.exe","") not in (os.path.abspath(panda3d.__file__)): 
+                print(f"Installing {pkgName} to {pythonExec}")
+                subprocess_call( [pythonExec, "-m", "pip", "install", f"{pkgName}=={pkgVersion}"])
+    except Exception as e:
+        print(f"{pkgName} not installed")
+        subprocess_call( [pythonExec, "-m", "pip", "install", f"{pkgName}=={pkgVersion}"])
+
+    # Check if package needs updating
+    r'''
+    try:
+        print(f"Attempting to update {pkgName} to {pkgVersion}")
+        result = subprocess_call(
+            [
+                pythonExec,
+                "-m",
+                "pip",
+                "install",
+                "--upgrade",
+                f"{pkgName}=={pkgVersion}",
+            ]
+        )
+        if result == True:
+            print(f"{pkgName} upgraded")
+            return True
+        else: 
+            return False
+    except Exception as e:
+        print(e)
+        print(e.with_traceback)
+    '''
+    return True
+    
+pythonPath = setup()
+if pythonPath is not None:
+    installToolbox(pythonPath)
+    installDependencies(pythonPath, "specklepy", "2.9.0"  )
+    installDependencies(pythonPath, "panda3d", "1.10.11" )

speckle_arcgis_installer/manual_toolbox_install.py

@@ -1,73 +0,0 @@
-# MANUAL INSTALLATION: 
-#   1. enter correct path to Python exe of your new environemnt in line 10 
-#   2. enter the location of 'manual_toolbox_install.py' in the following command and run this command in ArcGIS Python console (View -> Python Window)
-#   import sysconfig; import subprocess; x = sysconfig.get_paths()['data'] + r"\python.exe"; subprocess.run((x, 'C:\\Users\\Kateryna\\Documents\\00_Speckle\\GitHub\\speckle-arcgis\\speckle_arcgis_installer\\manual_toolbox_install.py'), capture_output=True, text=True, shell=True, timeout=1000 )
-# then restart
-
-from subprocess_call import subprocess_call
-import os 
-
-pythonPath = "C:\\ Users\\Kateryna\\AppData\\Local\\ESRI\\conda\\envs\\arcgispro-py3-speckle\\python.exe"
-
-def installToolbox(newExec: str):
-    print("Installing Speckle Toolbox")
-    whl_file = os.path.join(os.path.dirname(__file__), "speckle_toolbox-0.1-py3-none-any.whl" ) 
-    subprocess_call([newExec, '-m','pip','install','--upgrade', '--force-reinstall', whl_file])
-    return
-
-def installDependencies(pythonExec: str):
-    print("Installing dependencies")
-    print(pythonExec)
-    try:
-        import pip
-    except:
-        getPipFilePath = os.path.join(os.path.dirname(__file__), "get_pip.py") 
-        exec(open(getPipFilePath).read())
-
-        # just in case the included version is old
-        subprocess_call([pythonExec, "-m", "pip", "install", "--upgrade", "pip"])
-    
-    pkgVersion = "2.7.4" 
-    pkgName = "specklepy"
-    try:
-        import specklepy 
-    except Exception as e:
-        subprocess_call([ pythonExec, "-m", "pip", "install", f"{pkgName}=={pkgVersion}"])
-
-    
-    pkgVersion = "1.10.11" 
-    pkgName = "panda3d"
-    try:
-        import panda3d
-    except Exception as e:
-        print("panda3d not installed")
-        subprocess_call( [pythonExec, "-m", "pip", "install", f"{pkgName}=={pkgVersion}"])
-
-    # Check if specklpy needs updating
-    try:
-        print(f"Attempting to update specklepy to {pkgVersion}")
-        # pip.main(['install', "specklepy==2.7.4"])
-        result = subprocess_call(
-            [
-                pythonExec,
-                "-m",
-                "pip",
-                "install",
-                "--upgrade",
-                f"{pkgName}=={pkgVersion}",
-            ]
-        )
-        if result == True:
-            print("specklepy upgraded")
-            return True
-        else: 
-            return False
-
-    except Exception as e:
-        print(e)
-        print(e.with_traceback)
-    return True
-
-installToolbox(pythonPath)
-installDependencies(pythonPath)
-

speckle_arcgis_installer/subprocess_call.py

@@ -19,7 +19,7 @@ def subprocess_call(*args, **kwargs):
     try: 
         # if manually: cmd.exe -> conda activate [env folder] -> pip install specklepy 
         result = subprocess.run(*args, capture_output=True, text=True, shell=True, timeout=1000)
-        #print(result)
+        print(result)
         #result = subprocess.Popen( arg, shell=True, stdout=subprocess.PIPE) #, stderr=subprocess.STDOUT)
         #retcode = subprocess.check_call(*args, **kwargs) # Creates infinite loop, known issue: https://github.com/python/cpython/issues/87512
     except CalledProcessError as e: 
@@ -32,7 +32,7 @@ def subprocess_call(*args, **kwargs):
         #print(str(e))
         return False
     except: print("unknown error") 
-    print("end")
+    #print("end")
     return True
 
     

speckle_arcgis_installer/toolbox_install.py

@@ -6,65 +6,34 @@ pythonPath = os.getenv('APPDATA').replace("\\Roaming","") + r"\Local\ESRI\conda\
 
 def installToolbox(newExec: str):
     print("Installing Speckle Toolbox")
-    whl_file = os.path.join(os.path.dirname(__file__), "speckle_toolbox-2.9.3-py3-none-any.whl" ) 
+    whl_file = os.path.join(os.path.dirname(__file__), "speckle_toolbox-2.9.4-py3-none-any.whl" ) 
     print(whl_file)
     subprocess_call([newExec, '-m','pip','install','--upgrade', '--force-reinstall', whl_file])
-    # to uninstall: cmd.exe "C:\\Users\\username\\AppData\\Local\\ESRI\\conda\\envs\\arcgispro-2.9.3-py3-none-any.whl
+    # to uninstall: cmd.exe "C:\\Users\\username\\AppData\\Local\\ESRI\\conda\\envs\\arcgispro-2.9.4-py3-none-any.whl
     return
 
-def installDependencies(pythonExec: str):
-    #print("Installing dependencies")
+def installDependencies(pythonExec: str, pkgName: str, pkgVersion: str):
+    # install pip
     print(pythonExec)
     try:
         import pip
     except:
         getPipFilePath = os.path.join(os.path.dirname(__file__), "get_pip.py") #TODO: give actual folder path 
         exec(open(getPipFilePath).read())
-
         # just in case the included version is old
         subprocess_call([pythonExec, "-m", "pip", "install", "--upgrade", "pip"])
-    
-    pkgVersion = "2.9.0" 
-    pkgName = "specklepy"
+        
+    # install package
     try:
-        import specklepy # C:\Users\username\AppData\Roaming\Python\Python37\site-packages\specklepy\__init__.py 
+        import importlib
+        importlib.import_module(pkgName)
     except Exception as e:
-        subprocess_call([ pythonExec, "-m", "pip", "install", f"{pkgName}=={pkgVersion}"])
-
-    # Check if specklpy needs updating
-    try:
-        print(f"Attempting to update specklepy to {pkgVersion}")
-        result = subprocess_call(
-            [
-                pythonExec,
-                "-m",
-                "pip",
-                "install",
-                "--upgrade",
-                f"{pkgName}=={pkgVersion}",
-            ]
-        )
-        if result == True:
-            print("specklepy upgraded")
-            return True
-        else: 
-            return False
-
-    except Exception as e:
-        print(e)
-        print(e.with_traceback)
-
-    pkgVersion = "1.10.11" 
-    pkgName = "panda3d"
-    try:
-        import panda3d
-    except Exception as e:
-        print("panda3d not installed")
+        print(f"{pkgName} not installed")
         subprocess_call( [pythonExec, "-m", "pip", "install", f"{pkgName}=={pkgVersion}"])
 
-    # Check if specklpy needs updating
+    # Check if package needs updating
     try:
-        print(f"Attempting to update panda3d to {pkgVersion}")
+        print(f"Attempting to update {pkgName} to {pkgVersion}")
         result = subprocess_call(
             [
                 pythonExec,
@@ -76,16 +45,17 @@ def installDependencies(pythonExec: str):
             ]
         )
         if result == True:
-            print("dependencies upgraded")
+            print(f"{pkgName} upgraded")
             return True
         else: 
             return False
-
     except Exception as e:
         print(e)
         print(e.with_traceback)
     return True
 
-installToolbox(pythonPath)
-installDependencies(pythonPath)
+
+installToolbox(pythonPath)
+installDependencies(pythonPath, "specklepy", "2.9.0"  )
+installDependencies(pythonPath, "panda3d", "1.10.11" )
 

speckle_arcgis_installer/toolbox_install_manual.py

@@ -0,0 +1,57 @@
+# MANUAL INSTALLATION: 
+#   1. Clone the default ArcGIS Pro conda environment 
+#       for 2.9.0: Project-> Python-> Manage Environments-> Clone Default
+#       for 3.0.0: Project-> Package Manager-> Active Environment (Environment Manager)-> Clone arcgispro-py3
+#   2. Change the path to your new environemnt Python.exe if necessary (in variable "pythonPath" below, line 13) 
+#   3. Enter the location of 'toolbox_install_manual.py' in the following command and run this command in ArcGIS Python console (View -> Python Window)
+#   import sysconfig; import subprocess; x = sysconfig.get_paths()['data'] + r"\python.exe"; subprocess.run((x, 'C:\\Users\\myusername\\Documents\\manual_toolbox_install.py'), capture_output=True, text=True, shell=True, timeout=1000 )
+#   4. Restart ArcGIS Pro 
+
+from subprocess_call import subprocess_call
+import os 
+
+pythonPath = os.getenv('APPDATA').replace("\\Roaming","") + r"\Local\ESRI\conda\envs\arcgispro-py3-speckle\python.exe"
+
+def installToolbox(newExec: str):
+    print("Installing Speckle Toolbox")
+    whl_file = os.path.join(os.path.dirname(__file__), "speckle_toolbox-2.9.4-py3-none-any.whl" ) 
+    subprocess_call([newExec, '-m','pip','install','--upgrade', '--force-reinstall', whl_file])
+    return
+
+def installDependencies(pythonExec: str, pkgName: str, pkgVersion: str):
+    # install package
+    try:
+        #import importlib #importlib.import_module(pkgName)
+        if pkgName == "specklepy": import specklepy 
+        elif pkgName == "panda3d": import panda3d 
+    except Exception as e:
+        print(f"{pkgName} not installed")
+        subprocess_call( [pythonExec, "-m", "pip", "install", f"{pkgName}=={pkgVersion}"])
+
+    # Check if package needs updating
+    try:
+        print(f"Attempting to update {pkgName} to {pkgVersion}")
+        result = subprocess_call(
+            [
+                pythonExec,
+                "-m",
+                "pip",
+                "install",
+                "--upgrade",
+                f"{pkgName}=={pkgVersion}",
+            ]
+        )
+        if result == True:
+            print(f"{pkgName} upgraded")
+            return True
+        else: 
+            return False
+    except Exception as e:
+        print(e)
+        print(e.with_traceback)
+    return True
+
+installToolbox(pythonPath)
+installDependencies(pythonPath, "specklepy", "2.9.0"  )
+installDependencies(pythonPath, "panda3d", "1.10.11" )
+

speckle_toolbox/esri/toolboxes/Speckle.pyt

@@ -1,764 +1 @@
-#from speckle.speckle_arcgis import *
-
-# -*- coding: utf-8 -*-
-
-from typing import Any, Callable, List, Optional, Tuple
-#r'''
-from collections import defaultdict
-
-import arcpy
-#from arcpy import toolbox
-from arcpy._mp import ArcGISProject, Map, Layer as arcLayer
-from arcpy import metadata as md
-
-from specklepy.api.models import Branch, Stream, Streams
-from speckle.converter.layers.Layer import Layer, RasterLayer
-
-from speckle.converter.layers._init_ import convertSelectedLayers, layerToNative, cadLayerToNative
-from arcgis.features import FeatureLayer
-import os
-import os.path
-
-import specklepy
-from specklepy.transports.server.server import ServerTransport
-from specklepy.api.credentials import get_local_accounts
-from specklepy.api.client import SpeckleClient
-from specklepy.api import operations
-from specklepy.logging.exceptions import (
-    GraphQLException,
-    SpeckleException,
-    SpeckleWarning,
-)
-#from specklepy.api.credentials import StreamWrapper
-from specklepy.api.wrapper import StreamWrapper
-from specklepy.objects import Base
-from specklepy.logging import metrics
-
-from speckle.ui.project_vars import toolboxInputsClass, speckleInputsClass
-from speckle.converter.layers.emptyLayerTemplates import createGroupLayer
-from speckle.converter.layers.Layer import VectorLayer
-
-#'''
-
-def traverseObject(
-        base: Base,
-        callback: Optional[Callable[[Base], bool]],
-        check: Optional[Callable[[Base], bool]],
-    ):
-        if check and check(base):
-            res = callback(base) if callback else False
-            if res:
-                return
-        memberNames = base.get_member_names()
-        for name in memberNames:
-            try:
-                if ["id", "applicationId", "units", "speckle_type"].index(name):
-                    continue
-            except:
-                pass
-            traverseValue(base[name], callback, check)
-            
-def traverseValue(
-    value: Any,
-    callback: Optional[Callable[[Base], bool]],
-    check: Optional[Callable[[Base], bool]],
-):
-    if isinstance(value, Base):
-        traverseObject(value, callback, check)
-    if isinstance(value, List):
-        for item in value:
-            traverseValue(item, callback, check)
-
-
-class Toolbox:
-    def __init__(self):
-        """Define the toolbox (the name of the toolbox is the name of the
-        .pyt file)."""
-        print("___ping_Toolbox")
-        self.label = "Speckle Tools"
-        self.alias = "speckle_toolbox_"  
-        # List of tool classes associated with this toolbox
-        self.tools = [Speckle]  
-        metrics.set_host_app("ArcGIS")  
-
-        # https://pro.arcgis.com/en/pro-app/2.8/arcpy/mapping/alphabeticallistofclasses.htm#except: print("something happened")
-
-class Speckle:
-    def __init__(self):
-        #print("________________reset_______________")   
-        self.label       = "Speckle"
-        self.description = "Allows you to send and receive your layers " + \
-                           "to/from other software using Speckle server." 
-
-        self.toRefresh = False
-        self.speckleInputs = None
-        self.toolboxInputs = None
-        #print("ping_Speckle1")
-        
-        #print(speckleInputsClass.instances)
-        total = len(speckleInputsClass.instances)
-        #print(total)
-        for i in range(total):
-            #print(i)
-            #print(speckleInputsClass.instances[total-i-1])
-            if speckleInputsClass.instances[total-i-1] is not None: 
-                try: 
-                    #print(speckleInputsClass.instances[total-i-1].streams_default)
-                    y = speckleInputsClass.instances[total-i-1].streams_default # in case not initialized properly 
-                    self.speckleInputs = speckleInputsClass.instances[total-i-1] # take latest (first in reverted list)
-                    #print("FOUND INSTANCE")
-                    break
-                except: pass
-        #print(self.speckleInputs)
-        if self.speckleInputs is None: self.speckleInputs = speckleInputsClass()
-
-
-        #print(toolboxInputsClass.instances)
-        #print("TOTAL = ...................") 
-        total = len(toolboxInputsClass.instances)
-        #print(total)
-        for i in range(total):
-            if toolboxInputsClass.instances[total-i-1] is not None: 
-                self.toolboxInputs = toolboxInputsClass.instances[total-i-1] # take latest (first in reverted list)
-                #print("FOUND INSTANCE")
-                break
-        #print(self.toolboxInputs)
-        if self.toolboxInputs is None: self.toolboxInputs = toolboxInputsClass()
-        
-        #print("ping_Speckle2")
-
-    def getParameterInfo(self):
-        #data types: https://pro.arcgis.com/en/pro-app/2.8/arcpy/geoprocessing_and_python/defining-parameter-data-types-in-a-python-toolbox.htm
-        # parameter details: https://pro.arcgis.com/en/pro-app/latest/arcpy/geoprocessing_and_python/customizing-tool-behavior-in-a-python-toolbox.htm
-        print("Get parameter values")
-        cat1 = "Add Streams"
-        cat2 = "Send/Receive"
-        cat3 = "Create custom Spatial Reference"
-
-        streamsDefalut = arcpy.Parameter(
-            displayName="Add stream from default account",
-            name="streamsDefalut",
-            datatype="GPString",
-            parameterType="Optional",
-            #category="Sending data",
-            direction="Input",
-            category=cat1
-            )
-        streamsDefalut.filter.type = 'ValueList'
-        streamsDefalut.filter.list = [ (st.name + " - " + st.id) for st in self.speckleInputs.streams_default ]
-
-        addDefStreams = arcpy.Parameter(
-            displayName="Add",
-            name="addDefStreams",
-            datatype="GPBoolean",
-            parameterType="Optional",
-            #category="Sending data",
-            direction="Input",
-            category=cat1
-            )
-        addDefStreams.value = False 
-
-        streamUrl = arcpy.Parameter(
-            displayName="Add stream by URL",
-            name="streamUrl",
-            datatype="GPString",
-            parameterType="Optional",
-            direction="Input",
-            category=cat1
-            )
-        streamUrl.value = ""
-
-        addUrlStreams = arcpy.Parameter(
-            displayName="Add",
-            name="addUrlStreams",
-            datatype="GPBoolean",
-            parameterType="Optional",
-            direction="Input",
-            category=cat1
-            )
-        addUrlStreams.value = False 
-
-        ############################################################################
-        
-        lat = arcpy.Parameter(
-            displayName="Origin point LAT",
-            name="lat",
-            datatype="GPString",
-            parameterType="Optional",
-            direction="Input",
-            category=cat3
-            )
-        lat.value = str(self.toolboxInputs.lat)
-
-        lon = arcpy.Parameter(
-            displayName="Origin point LON",
-            name="lon",
-            datatype="GPString",
-            parameterType="Optional",
-            direction="Input",
-            category=cat3
-            )
-        lon.value = str(self.toolboxInputs.lon)
-        
-        setLatLon = arcpy.Parameter(
-            displayName="Create and apply",
-            name="setLatLon",
-            datatype="GPBoolean",
-            parameterType="Optional",
-            direction="Input",
-            category=cat3
-            )
-        setLatLon.value = False
-        
-        ####################################################################################################
-
-        savedStreams = arcpy.Parameter(
-            displayName="Select Stream",
-            name="savedStreams",
-            datatype="GPString",
-            parameterType="Required",
-            direction="Input",
-            multiValue=False,
-            #category=cat2
-            )
-        savedStreams.filter.list = [f"Stream not accessible - {stream[0].stream_id}" if stream[1] is None or isinstance(stream[1], SpeckleException) else f"{stream[1].name} - {stream[1].id}" for i,stream in enumerate(self.speckleInputs.saved_streams)] 
-
-        removeStream = arcpy.Parameter(
-            displayName="Remove",
-            name="removeStream",
-            datatype="GPBoolean",
-            parameterType="Optional",
-            direction="Input"
-            )
-        removeStream.value = False 
-
-        branch = arcpy.Parameter(
-            displayName="Branch",
-            name="branch",
-            datatype="GPString",
-            parameterType="Required",
-            #category="Sending data",
-            direction="Input",
-            #category=cat2
-            )
-        branch.value = ""
-        branch.filter.type = 'ValueList'
-
-        commit = arcpy.Parameter(
-            displayName="Commit",
-            name="commit",
-            datatype="GPString",
-            parameterType="Optional",
-            #category="Sending data",
-            direction="Input",
-            #category=cat2
-            )
-        commit.value = ""
-        commit.filter.type = 'ValueList'
-
-        msg = arcpy.Parameter(
-            displayName="Message",
-            name="message",
-            datatype="GPString",
-            parameterType="Optional",
-            direction="Input",
-            multiValue=False,
-            #category=cat2
-            )
-        msg.value = ""
-
-        selectedLayers = arcpy.Parameter(
-            displayName="Selected Layers",
-            name="selectedLayers",
-            datatype="GPString",
-            parameterType="Optional",
-            direction="Input",
-            multiValue=True,
-            #category=cat2
-            )
-        selectedLayers.filter.list = [str(i) + "-" + l.longName for i,l in enumerate(self.speckleInputs.all_layers)] #"Polyline"
-
-        
-        action = arcpy.Parameter(
-            displayName="",
-            name="action",
-            datatype="GPString",
-            parameterType="Required",
-            #category="Sending data",
-            direction="Input",
-            multiValue=False,
-            #category=cat2
-            )
-        action.value = "Send" 
-        #action.filter.type = 'ValueList'
-        action.filter.list = ["Send", "Receive"]  
-
-        refresh = arcpy.Parameter(
-            displayName="Refresh",
-            name="refresh",
-            datatype="GPBoolean",
-            parameterType="Optional",
-            direction="Input"
-            )
-        #refresh.filter.type = "ValueList"   
-        refresh.value = False 
-
-        parameters = [streamsDefalut, addDefStreams, streamUrl, addUrlStreams, lat, lon, setLatLon, savedStreams, removeStream, branch, commit, selectedLayers, msg, action, refresh]
-        return parameters
-
-    def isLicensed(self): #optional
-        return True
-
-    def updateParameters(self, parameters: List, toRefresh = False): #optional
-        print("UPDATING PARAMETERS")
-        
-        for i, par in enumerate(parameters): 
-            
-
-            if par.name == "addDefStreams" and par.altered and par.value == True: 
-                for p in parameters:
-                    if p.name == "streamsDefalut" and p.valueAsText is not None:
-                        # add value from streamsDefault to saved streams
-                        selected_stream_name = p.valueAsText[:]
-                        #print(selected_stream_name)
-                        for stream in self.speckleInputs.streams_default:
-                            #print(stream)
-                            if stream.name == selected_stream_name.split(" - ")[0]:
-                                print("_____Add from list___")
-                                wr = StreamWrapper(f"{self.speckleInputs.account.serverInfo.url}/streams/{stream.id}?u={self.speckleInputs.account.userInfo.id}")
-                                self.toolboxInputs.setProjectStreams(wr)
-                                
-                                for p_saved in parameters:
-                                    if p_saved.name == "savedStreams": 
-                                        saved_streams = self.speckleInputs.getProjectStreams()
-                                        self.speckleInputs.saved_streams = saved_streams
-                                        p_saved.filter.list = [f"Stream not accessible - {stream[0].stream_id}" if stream[1] is None or isinstance(stream[1], SpeckleException) else f"{stream[1].name} - {stream[1].id}" for i,stream in enumerate(saved_streams)] 
-                                        if len(p_saved.filter.list)>0: print(p_saved.filter.list); p_saved.value = p_saved.filter.list[0]
-                                break
-                        p.value = None
-                par.value = False
-            
-            if par.name == "addUrlStreams" and par.altered and par.value == True: 
-                for p in parameters:
-                    if p.name == "streamUrl" and p.valueAsText is not None:
-
-                        # add value from streamsDefault to saved streams
-                        query = p.valueAsText[:]
-                        if "http" in query and len(query.split("/")) >= 3: # URL
-                            steamId = query
-                            try: steamId = query.split("/streams/")[1].split("/")[0] 
-                            except: pass
-                            # quesry stream, add to saved
-                            stream = self.speckleInputs.speckle_client.stream.get(steamId)
-                            if isinstance(stream, Stream): 
-                                print("_____Add by URL___")
-                                wr = StreamWrapper(f"{self.speckleInputs.account.serverInfo.url}/streams/{stream.id}?u={self.speckleInputs.account.userInfo.id}")
-                                self.toolboxInputs.setProjectStreams(wr)
-                                
-                                for p_saved in parameters:
-                                    if p_saved.name == "savedStreams": 
-                                        saved_streams = self.speckleInputs.getProjectStreams()
-                                        self.speckleInputs.saved_streams = saved_streams
-                                        p_saved.filter.list = [f"Stream not accessible - {st[0].stream_id}" if st[1] is None or isinstance(st[1], SpeckleException) else f"{st[1].name} - {st[1].id}" for i,st in enumerate(saved_streams)] 
-                                        if len(p_saved.filter.list)>0: print(p_saved.filter.list); p_saved.value = p_saved.filter.list[0]
-                            else: pass
-
-                        p.value = None
-                        break
-                par.value = False
-
-
-            if par.name == "removeStream" and par.altered and par.value == True: 
-                for p in parameters:
-                    if p.name == "savedStreams" and p.valueAsText is not None:
-
-                         # get value from savedStreams 
-                        selected_stream_name = p.valueAsText[:]
-                        #print(selected_stream_name)
-                        for streamTup in self.speckleInputs.saved_streams:
-                            #print(stream)
-                            stream = streamTup[1]
-                            if stream.name == selected_stream_name.split(" - ")[0]:
-                                print("_____Remove stream___")
-                                wr = StreamWrapper(f"{self.speckleInputs.account.serverInfo.url}/streams/{stream.id}?u={self.speckleInputs.account.userInfo.id}")
-                                self.toolboxInputs.setProjectStreams(wr, False)
-                                
-                                for p_saved in parameters:
-                                    if p_saved.name == "savedStreams": 
-                                        saved_streams = self.speckleInputs.getProjectStreams()
-                                        self.speckleInputs.saved_streams = saved_streams
-                                        p_saved.filter.list = [f"Stream not accessible - {st[0].stream_id}" if st[1] is None or isinstance(st[1], SpeckleException) else f"{st[1].name} - {st[1].id}" for i,st in enumerate(saved_streams)] 
-                                        p_saved.value = None
-                                break
-                        p.value = None
-                par.value = False
-
-            ####################################################################### 
-            if par.name == "setLatLon" and par.altered and par.value == True: 
-                lat = lon = 0
-                for p in parameters:
-                    if p.name == "lat" and p.valueAsText is not None:
-                        # add value from the UI to saved lat
-                        lat = p.valueAsText[:].replace(",","").replace(" ","").replace(";","").replace("-","").replace("_","")
-                        try: lat = float(lat)
-                        except: lat = 0; p.value = "0.0"
-                    if p.name == "lon" and p.valueAsText is not None:
-                        # add value from the UI to saved lat
-                        lon = p.valueAsText[:].replace(",","").replace(" ","").replace(";","").replace("-","").replace("_","")
-                        try: lon = float(lon)
-                        except: lon = 0; p.value = "0.0"
-                    coords = [lat, lon]
-                    self.toolboxInputs.set_survey_point(coords)
-                par.value = False
-            
-            ####################################################################### 
-
-            if par.name == "savedStreams" and par.altered:
-                # Search for the stream by name
-                if par.value is not None and "Stream not accessible" not in par.valueAsText[:]:
-                    #print("SAVED STREAMS - selection")
-                    selected_stream_name = par.valueAsText[:]
-                    self.toolboxInputs.active_stream = None
-                    for st in self.speckleInputs.saved_streams:
-                        if st[1].name == selected_stream_name.split(" - ")[0]: 
-                            self.toolboxInputs.active_stream = st[1]
-                            break
-
-                    # edit branches: globals and UI 
-                    branch_list = [branch.name for branch in self.toolboxInputs.active_stream.branches.items]
-                    for p in parameters:
-                        if p.name == "branch":
-                            p.filter.list = branch_list
-
-                            if p.valueAsText not in branch_list: 
-                                p.value = "main"
-                            for b in self.toolboxInputs.active_stream.branches.items:
-                                if b.name == p.value: 
-                                    self.toolboxInputs.active_branch = b
-                                    break 
-                    
-                    # setting commit value and list 
-                    for p in parameters:
-                        if p.name == "commit":
-                            try: 
-                                p.filter.list = [f"{commit.id}"+ " - " + f"{commit.message}" for commit in self.toolboxInputs.active_branch.commits.items]
-                                if p.valueAsText not in p.filter.list:
-                                    p.value = self.toolboxInputs.active_branch.commits.items[0].id + " - " + self.toolboxInputs.active_branch.commits.items[0].message 
-                                    self.toolboxInputs.active_commit = self.toolboxInputs.active_branch.commits.items[0] 
-                            except: 
-                                p.filter.list = []
-                                p.value = None
-                                self.toolboxInputs.active_commit = None 
-                else: par.value = None
-                #print(self.toolboxInputs.action)
-
-            if par.name == "branch" and par.altered: # branches
-                if par.value is not None:
-                    selected_branch_name = par.valueAsText[:]
-                    self.toolboxInputs.active_branch = None
-                    if self.toolboxInputs.active_stream is not None:
-                        for br in self.toolboxInputs.active_stream.branches.items:
-                            if br.name == selected_branch_name:
-                                self.toolboxInputs.active_branch = br
-                                break
-                # edit commit values 
-                if self.toolboxInputs.active_branch is not None: 
-                    for p in parameters:
-                        if p.name == "commit":
-                            try: 
-                                p.filter.list = [f"{commit.id}"+ " - " + f"{commit.message}" for commit in self.toolboxInputs.active_branch.commits.items]
-                                if p.valueAsText not in p.filter.list:
-                                    p.value = self.toolboxInputs.active_branch.commits.items[0].id + " - " + self.toolboxInputs.active_branch.commits.items[0].message 
-                                    self.toolboxInputs.active_commit = self.toolboxInputs.active_branch.commits.items[0]
-                            except: 
-                                p.filter.list = []
-                                p.value = None
-                                self.toolboxInputs.active_commit = None 
-
-            if par.name == "commit" and par.altered: # commits
-                if par.value is not None:
-                    selected_commit_id = par.valueAsText[:].split(" - ")[0]
-                    self.toolboxInputs.active_commit = None
-                    if self.toolboxInputs.active_branch is not None:
-                        for c in self.toolboxInputs.active_branch.commits.items:
-                            if c.id == selected_commit_id: 
-                                self.toolboxInputs.active_commit = c 
-                                break
-            
-            if par.name == "selectedLayers" and par.altered: # selected layers
-                if par.value is not None:
-                    self.toolboxInputs.selected_layers = par.values
-
-                    #print("selected layers changed")
-                    #print(self.toolboxInputs.action)
-                    #print(self.toolboxInputs.selected_layers)
-
-            if par.name == "msg" and par.altered and par.valueAsText is not None:
-                self.toolboxInputs.messageSpeckle = par.valueAsText
-
-            if par.name == "action" and par.altered:
-                #print("action changed")
-                #print(par.valueAsText)
-                if par.valueAsText == "Send": self.toolboxInputs.action = 1
-                else: self.toolboxInputs.action = 0
-
-                #print(self.toolboxInputs.action)
-                #print(self.toolboxInputs.selected_layers)
-
-            if par.name == "refresh" and par.altered: # refresh btn
-                if par.value == True: 
-                    self.refresh(parameters) 
-            if self.toRefresh == True:
-                self.refresh(parameters) 
-                self.toRefresh = False
-        
-        print("____________________________parameters___________________________")
-        #[print(str(x.name) + " - " + str(x.valueAsText)) for x in parameters]
-        #[x.clearMessage() for x in parameters] # https://pro.arcgis.com/en/pro-app/latest/arcpy/geoprocessing_and_python/programming-a-toolvalidator-class.htm
-        #[print(x.valueAsText) for x in parameters]
-        return 
-    
-    def refresh(self, parameters: List[Any]): 
-        print("Refresh______")
-        self.speckleInputs: speckleInputsClass = speckleInputsClass()
-        self.toolboxInputs: toolboxInputsClass = toolboxInputsClass()
-        
-        for par in parameters: 
-            if par.name == "streamUrl": par.value = None
-            if par.name == "streamsDefalut": par.value = None
-            if par.name == "savedStreams": par.value = None
-            if par.name == "branch": par.value = ""
-            if par.name == "commit": par.value = None
-            if par.name == "selectedLayers": par.value = None
-            if par.name == "msg": par.value = ""
-            if par.name == "action": par.value = "Send"
-            if par.name == "refresh": par.value = False
-            
-            if par.name == "lat": par.value = str(self.toolboxInputs.get_survey_point()[0])
-            if par.name == "lon": par.value = str(self.toolboxInputs.get_survey_point()[1])
-            if par.name == "streamsDefalut": par.filter.list = [ (st.name + " - " + st.id) for st in self.speckleInputs.streams_default ]
-            if par.name == "savedStreams": 
-                #print("par.name")
-                saved_streams = self.speckleInputs.getProjectStreams()
-                #print(saved_streams)
-                par.filter.list = [f"Stream not accessible - {stream[0].stream_id}" if stream[1] is None or isinstance(stream[1], SpeckleException) else f"{stream[1].name} - {stream[1].id}" for i,stream in enumerate(saved_streams)] 
-            if par.name == "selectedLayers": par.filter.list = [str(i) + "-" + l.longName for i,l in enumerate(self.speckleInputs.all_layers)]
-        
-        return parameters
-
-    def updateMessages(self, parameters): #optional
-        return
-
-    def execute(self, parameters: List, messages): 
-        # https://pro.arcgis.com/en/pro-app/latest/arcpy/get-started/what-is-arcpy-.htm
-        #Warning if any of the fields is invalid/empty 
-        print("___________________________Run___________________________")
-        check = self.validateStreamBranch(parameters) # apparently pdate needed to assign proper self.values
-        
-        print(self.toolboxInputs.selected_layers)
-        print(self.toolboxInputs.action)
-        
-        if self.toolboxInputs.action == 1 and check is True: self.onSend(parameters)
-        elif self.toolboxInputs.action == 0 and check is True: self.onReceive(parameters)
-        print("__________________________Run_end___________________________")
-
-    def validateStreamBranch(self, parameters: List):
-        	
-        self.updateParameters(parameters)
-        if self.toolboxInputs.active_stream is None:
-            arcpy.AddError("Choose a valid stream")
-            return False
-        if self.toolboxInputs.active_branch is None: 
-            arcpy.AddError("Choose a valid branch")
-            return False
-        return True 
-
-    def onSend(self, parameters: List):
-
-        print("______________SEND_______________")
-
-        #if self.validateStreamBranch(parameters) == False: return
-
-        if len(self.toolboxInputs.selected_layers) == 0: 
-            arcpy.AddError("No layers selected for sending")
-            return
-
-        streamId = self.toolboxInputs.active_stream.id #stream_id
-        client = self.speckleInputs.speckle_client # ?
-        
-        # Get the stream wrapper
-        #streamWrapper = StreamWrapper(None)
-        #client = streamWrapper.get_client()
-        # Ensure the stream actually exists
-        #try:
-        #    client.stream.get(streamId)
-        #except SpeckleException as error:
-        #    print(str(error))
-        #    return
-
-        # next create a server transport - this is the vehicle through which you will send and receive
-        transport = ServerTransport(client=client, stream_id=streamId)
-
-        ##################################### conversions ################################################
-        base_obj = Base(units = "m")
-        base_obj.layers = convertSelectedLayers(self.speckleInputs.all_layers, self.toolboxInputs.selected_layers, self.speckleInputs.project)
-        
-        try:
-            # this serialises the block and sends it to the transport
-            objId = operations.send(base=base_obj, transports=[transport])
-        except SpeckleException as error:
-            arcpy.AddError("Error sending data")
-            #print("Error sending data")
-            return
-        except SpeckleWarning as warning:
-            arcpy.AddMessage("SpeckleWarning: " + str(warning.args[0]))
-            
-
-        message = self.toolboxInputs.messageSpeckle
-        if message is None or ( isinstance(message, str) and len(message) == 0):  message = "Sent from ArcGIS"
-        try:
-            # you can now create a commit on your stream with this object
-            client.commit.create(
-                stream_id=streamId,
-                object_id=objId,
-                branch_name=self.toolboxInputs.active_branch.name,
-                message=message,
-                source_application="ArcGIS",
-            )
-            arcpy.AddMessage("Successfully sent data to stream: " + streamId)
-        except:
-            arcpy.AddError("Error creating commit")
-
-    def onReceive(self, parameters: List[Any]): 
-        
-        print("______________RECEIVE_______________")
-
-        #if self.validateStreamBranch(parameters) == False: return
-
-        try: 
-            streamId = self.toolboxInputs.active_stream.id #stream_id
-            client = self.speckleInputs.speckle_client # 
-        except SpeckleWarning as warning: 
-            arcpy.AddWarning(str(warning.args[0]))
-
-        # get commit 
-        commit = None 
-        try: 
-            #commit = self.toolboxInputs.active_branch.commits.items[0]
-            commit = self.toolboxInputs.active_commit
-            commitId = commit.id # text to make sure commit exists 
-        except: 
-            try: 
-                commit = self.toolboxInputs.active_branch.commits.items[0]
-                commitId = commit.id 
-                arcpy.AddWarning("Failed to find a commit. Getting the last commit of the branch")
-            except:
-                arcpy.AddError("Failed to find a commit")
-                return
-
-        # next create a server transport - this is the vehicle through which you will send and receive
-        try: 
-            transport = ServerTransport(client=client, stream_id=streamId)
-            
-            client.commit.received(
-            streamId,
-            commit.id,
-            source_application="ArcGIS",
-            message="Received commit in ArcGIS",
-            )
-        except: 
-            arcpy.AddError("Make sure your account has access to the chosen stream")
-            return
-
-        try:
-            #print(commit)
-            objId = commit.referencedObject
-            commitDetailed = client.commit.get(streamId, commit.id)
-            app = commitDetailed.sourceApplication
-            if objId is None:
-                return
-            commitObj = operations.receive(objId, transport, None)
-            
-            if app != "QGIS" and app != "ArcGIS": 
-                if self.speckleInputs.project.activeMap.spatialReference.type == "Geographic" or self.speckleInputs.project.activeMap.spatialReference is None: #TODO test with invalid CRS
-                    arcpy.AddMessage("It is advisable to set the project Spatial reference to Projected type before receiving CAD geometry (e.g. EPSG:32631), or create a custom one from geographic coordinates")
-                    print("It is advisable to set the project Spatial reference to Projected type before receiving CAD geometry (e.g. EPSG:32631), or create a custom one from geographic coordinates")
-            print(f"Succesfully received {objId}")
-
-            # Clear 'latest' group
-            streamBranch = streamId + "_" + self.toolboxInputs.active_branch.name + "_" + str(commit.id)
-            newGroupName = f'{streamBranch}'
-            
-            groupExists = 0
-            #print(newGroupName)
-            for l in self.speckleInputs.project.activeMap.listLayers(): 
-                #print(l.longName)
-                if l.longName.startswith(newGroupName + "\\"):
-                    #print(l.longName)
-                    self.speckleInputs.project.activeMap.removeLayer(l)
-                    groupExists+=1
-                elif l.longName == newGroupName: 
-                    groupExists+=1
-            if groupExists == 0:
-                # create empty group layer file 
-                path = self.speckleInputs.project.filePath.replace("aprx","gdb") #"\\".join(self.toolboxInputs.project.filePath.split("\\")[:-1]) + "\\speckle_layers\\"
-                #print(path)
-                f = open(path + "\\" + newGroupName + ".lyrx", "w")
-                content = createGroupLayer().replace("TestGroupLayer", newGroupName)
-                f.write(content)
-                f.close()
-                smth = arcpy.mp.LayerFile(path + "\\" + newGroupName + ".lyrx")
-                #print(smth)
-                layerGroup = self.speckleInputs.project.activeMap.addLayer(smth)[0]
-                layerGroup.name = newGroupName
-
-            if app == "QGIS" or app == "ArcGIS": check: Callable[[Base], bool] = lambda base: isinstance(base, Layer) or isinstance(base, VectorLayer) or isinstance(base, RasterLayer)
-            else: check: Callable[[Base], bool] = lambda base: isinstance(base, Base)
-
-            def callback(base: Base) -> bool:
-                print("callback")
-                #print(base)
-                if isinstance(base, Layer) or isinstance(base, VectorLayer) or isinstance(base, RasterLayer):
-                    layer = layerToNative(base, streamBranch, self.speckleInputs.project)
-                    if layer is not None:
-                        print("Layer created: " + layer.name)
-                else:
-                    loopObj(base, "")
-                return True
-            
-            def loopObj(base: Base, baseName: str):
-                memberNames = base.get_member_names()
-                for name in memberNames:
-                    if name in ["id", "applicationId", "units", "speckle_type"]: continue
-                    try: loopVal(base[name], baseName + "/" + name) # loop properties not included above
-                    except: pass
-
-            def loopVal(value: Any, name: str): # "name" is the parent object/property/layer name
-                if isinstance(value, Base): 
-                    try: # dont go through parts of Speckle Geometry object
-                        print("objects to loop through: " + value.speckle_type)
-                        if value.speckle_type.startswith("Objects.Geometry."): pass #.Brep") or value.speckle_type.startswith("Objects.Geometry.Mesh") or value.speckle_type.startswith("Objects.Geometry.Surface") or value.speckle_type.startswith("Objects.Geometry.Extrusion"): pass
-                        else: loopObj(value, name)
-                    except: loopObj(value, name)
-
-                if isinstance(value, List):
-                    for item in value:
-                        loopVal(item, name)
-                        #print(item)
-                        if item.speckle_type and item.speckle_type.startswith("Objects.Geometry."): 
-                            pt, pl = cadLayerToNative(value, name, streamBranch, self.speckleInputs.project)
-                            if pt is not None: print("Layer group created: " + pt.name())
-                            if pl is not None: print("Layer group created: " + pl.name())
-                            break
-                
-            traverseObject(commitObj, callback, check)
-      
-        except SpeckleException as e:
-            print("Receive failed")
-            return
-        print("received")
-        #self.updateParameters(parameters, True)
-        #self.refresh(parameters)
-    
-    
-#__all__ = ["Toolbox", "Speckle"]
+from speckle.speckle_arcgis import *

speckle_toolbox/esri/toolboxes/Speckle.pyt.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0"?>
-<metadata xml:lang="en"><Esri><CreaDate>20220718</CreaDate><CreaTime>13500100</CreaTime><ArcGISFormat>1.0</ArcGISFormat><SyncOnce>TRUE</SyncOnce><ModDate>20221025</ModDate><ModTime>190532</ModTime><scaleRange><minScale>150000000</minScale><maxScale>5000</maxScale></scaleRange><ArcGISProfile>ItemDescription</ArcGISProfile></Esri><toolbox name="Speckle" alias="speckle_toolbox_"><arcToolboxHelpPath>c:\program files\arcgis\pro\Resources\Help\gp</arcToolboxHelpPath><toolsets/></toolbox><dataIdInfo><idCitation><resTitle>Speckle</resTitle></idCitation><idPurp>Speckle connector for ArcGIS</idPurp><searchKeys><keyword>speckle3d</keyword></searchKeys></dataIdInfo><distInfo><distributor><distorFormat><formatName>ArcToolbox Toolbox</formatName></distorFormat></distributor></distInfo><mdHrLv><ScopeCd value="005"></ScopeCd></mdHrLv><Binary><Thumbnail><Data EsriPropertyType="PictureX">/9j/4AAQSkZJRgABAQEAYABgAAD/4gxYSUNDX1BST0ZJTEUAAQEAAAxITGlubwIQAABtbnRyUkdC
+<metadata xml:lang="en"><Esri><CreaDate>20220718</CreaDate><CreaTime>13500100</CreaTime><ArcGISFormat>1.0</ArcGISFormat><SyncOnce>TRUE</SyncOnce><ModDate>20221031</ModDate><ModTime>212303</ModTime><scaleRange><minScale>150000000</minScale><maxScale>5000</maxScale></scaleRange><ArcGISProfile>ItemDescription</ArcGISProfile></Esri><toolbox name="Speckle" alias="speckle_toolbox_"><arcToolboxHelpPath>c:\program files\arcgis\pro\Resources\Help\gp</arcToolboxHelpPath><toolsets/></toolbox><dataIdInfo><idCitation><resTitle>Speckle</resTitle></idCitation><idPurp>Speckle connector for ArcGIS</idPurp><searchKeys><keyword>speckle3d</keyword></searchKeys></dataIdInfo><distInfo><distributor><distorFormat><formatName>ArcToolbox Toolbox</formatName></distorFormat></distributor></distInfo><mdHrLv><ScopeCd value="005"></ScopeCd></mdHrLv><Binary><Thumbnail><Data EsriPropertyType="PictureX">/9j/4AAQSkZJRgABAQEAYABgAAD/4gxYSUNDX1BST0ZJTEUAAQEAAAxITGlubwIQAABtbnRyUkdC
 IFhZWiAHzgACAAkABgAxAABhY3NwTVNGVAAAAABJRUMgc1JHQgAAAAAAAAAAAAAAAAAA9tYAAQAA
 AADTLUhQICAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABFj
 cHJ0AAABUAAAADNkZXNjAAABhAAAAGx3dHB0AAAB8AAAABRia3B0AAACBAAAABRyWFlaAAACGAAA

speckle_toolbox/esri/toolboxes/speckle/converter/geometry/point.py

@@ -55,19 +55,20 @@ def pointToNative(pt: Point, sr: arcpy.SpatialReference) -> arcpy.PointGeometry:
     #print(geom)
     return geom
 
-def pointToCoord(pt: Point) -> List[float]:
+def pointToCoord(point: Point) -> List[float]:
     """Converts a Speckle Point to QgsPoint"""
-    pt = scalePointToNative(pt, pt.units)
+    pt = scalePointToNative(point, point.units)
     coords = [pt.x, pt.y, pt.z]
     #print(coords)
     return coords
 
-def scalePointToNative(pt: Point, units: str) -> Point:
+def scalePointToNative(point: Point, units: str) -> Point:
     """Scale point coordinates to meters"""
     scaleFactor = get_scale_factor(units)
-    pt.x = pt.x * scaleFactor
-    pt.y = pt.y * scaleFactor
-    pt.z = 0 if math.isnan(pt.z) else pt.z * scaleFactor
+    pt = Point(units = "m")
+    pt.x = point.x * scaleFactor
+    pt.y = point.y * scaleFactor
+    pt.z = 0 if math.isnan(point.z) else point.z * scaleFactor
     return pt
 
 def addZtoPoint(coords: List): 

speckle_toolbox/esri/toolboxes/speckle/converter/geometry/polyline.py

@@ -26,6 +26,7 @@ def circleToSpeckle(center, point):
     #print(args) 
     c = Circle.from_list(args)
     c.plane.origin.units = "m"
+    c.units = "m"
     #print(c)
     return c 
 
@@ -107,6 +108,7 @@ def arc3ptToSpeckle(p0: List, p1: List, p2: List, feature, layer) -> Arc:
     arc.plane = Plane() #.from_list(Point(), Vector(Point(0, 0, 1)), Vector(Point(0,1,0)), Vector(Point(-1,0,0)))
     arc.plane.origin = Point.from_list(center)
     arc.plane.origin.units = "m" 
+    arc.units = "m"
     arc.angleRadians, startAngle, endAngle = getArcRadianAngle(arc)
 
     arc.radius = radius
@@ -173,7 +175,7 @@ def curveToSpeckle(geom, geomType, feature, layer) -> Union[Circle, Arc, Polylin
     # a - elliptical arc (endPt, centralPt) e.g. for circle: [[[631307.05960000027,5803698.4477999993,0],{"a":[[631307.05960000027,5803698.4477999993,0],[631307.05960000027,5803414.92656173],0,1]}]]
     # c - circular arc (endPt, throughPt) e.g. [[[633242.45179999992,5803058.0354999993,0],{"c":[[633718.26040000003,5803496.4210000001,0],[633337.75764975848,5803431.9997026781]]},[633242.45179999992,5803058.0354999993,0]]]
     
-    boundary = Polycurve()
+    boundary = Polycurve(units = "m")
     if geomType == "Polyline": boundary.closed = False
     else: boundary.closed = True 
     segments = [] 
@@ -326,7 +328,7 @@ def lineFrom2pt(pt1: List[float], pt2: List[float]):
     dist = math.sqrt( math.pow((pt2[0] - pt1[0]), 2) + math.pow((pt2[1] - pt1[1]), 2) + math.pow((pt2[2] - pt1[2]), 2) ) 
     print(dist) 
     domain = [0, dist, 0, 0] 
-    line = Line()#.from_list([*pt1, *pt2, *domain]) 
+    line = Line(units = "m" )#.from_list([*pt1, *pt2, *domain]) 
     line.start = Point.from_list(pt1)
     line.end = Point.from_list(pt2)
     line.start.units = line.end.units = "m" 
@@ -377,7 +379,7 @@ def ellipseToNative():
 
 def circleToNative(poly: Circle, sr: arcpy.SpatialReference) -> arcpy.Polyline:
     """Converts a Speckle Circle to QgsLineString"""
-    print("___Convert Circle from Native___")
+    print("___Convert Circle to Native___")
     points = []
     angle1 = math.pi/2
     
@@ -393,7 +395,8 @@ def circleToNative(poly: Circle, sr: arcpy.SpatialReference) -> arcpy.Polyline:
         if poly.plane.normal.z == 0: normal = 1
         else: normal = poly.plane.normal.z
         angle = angle1 + k * math.pi*2 * normal
-        pt = Point( x = poly.plane.origin.x + radScaled * cos(angle), y = poly.plane.origin.y + radScaled * sin(angle), z = 0) 
+        pt = Point( x = poly.plane.origin.x * get_scale_factor(poly.units) + radScaled * cos(angle), y = poly.plane.origin.y * get_scale_factor(poly.units) + radScaled * sin(angle), z = 0) 
+        print(pt)
         pt.units = "m"
         points.append(pointToCoord(pt))
     points.append(points[0])
@@ -404,10 +407,10 @@ def polycurveToNative(poly: Polycurve, sr: arcpy.SpatialReference) -> arcpy.Poly
     points = []
     curve = None
     print("___Polycurve to native___")
-    
-    try:
-        for segm in poly.segments: # Line, Polyline, Curve, Arc, Circle
-            #print(segm)
+
+    try: 
+        for i, segm in enumerate(poly.segments): # Line, Polyline, Curve, Arc, Circle
+            print("___start segment")            
             if isinstance(segm,Line):  converted = lineToNative(segm, sr) # QgsLineString
             elif isinstance(segm,Polyline):  converted = polylineToNative(segm, sr) # QgsLineString
             elif isinstance(segm,Curve):  converted = curveToNative(segm, sr) # QgsLineString
@@ -420,6 +423,7 @@ def polycurveToNative(poly: Polycurve, sr: arcpy.SpatialReference) -> arcpy.Poly
             if converted is not None: 
                 #print(converted) # <geoprocessing describe geometry object object at 0x000002B2D3E338D0>
                 for part in converted:
+                    #print("Part: ")
                     #print(part) # <geoprocessing array object object at 0x000002B2D2E09530>
                     for pt in part: 
                         #print(pt) # 64.4584221540162 5.5 NaN NaN
@@ -428,8 +432,7 @@ def polycurveToNative(poly: Polycurve, sr: arcpy.SpatialReference) -> arcpy.Poly
                         #print(pt_z)
                         #print(len(points)) 
                         if len(points)>0 and pt.X == points[len(points)-1][0] and pt.Y == points[len(points)-1][1] and pt_z == points[len(points)-1][2]: pass
-                        else: points.append(pointToCoord(Point(x=pt.X, y = pt.Y, z = pt_z)))
-                        #print(points)
+                        else: points.append(pointToCoord(Point(x=pt.X, y = pt.Y, z = pt_z, units = "m"))) # e.g. [[64.4584221540162, 5.499999999999999, 0.0], [64.45461685210796, 5.587155742747657, 0.0]]
             else:
                 arcpy.AddWarning(f"Part of the polycurve cannot be converted")
                 curve = arcpy.Polyline( arcpy.Array([arcpy.Point(*coords) for coords in points]), sr, has_z=True )
@@ -441,7 +444,7 @@ def polycurveToNative(poly: Polycurve, sr: arcpy.SpatialReference) -> arcpy.Poly
     return curve
 
 def arcToNativePolyline(poly: Union[Arc, Circle], sr: arcpy.SpatialReference):
-    print("__Arc/Circle to native__")
+    print("__Arc/Circle to native polyline__")
     pointsSpeckle = speckleArcCircleToPoints(poly)
     points = [pointToCoord(p) for p in pointsSpeckle]
     curve = arcpy.Polyline( arcpy.Array([arcpy.Point(*coords) for coords in points]), sr, has_z=True )
@@ -454,6 +457,7 @@ def specklePolycurveToPoints(poly: Polycurve) -> List[Point]:
     points = []
     for segm in poly.segments:
         print(segm)
+        pts = []
         if isinstance(segm, Arc) or isinstance(segm, Circle): # or isinstance(segm, Curve):
             print("Arc or Curve")
             pts: List[Point] = speckleArcCircleToPoints(segm) 
@@ -470,8 +474,8 @@ def specklePolycurveToPoints(poly: Polycurve) -> List[Point]:
 def speckleArcCircleToPoints(poly: Union[Arc, Circle]) -> List[Point]: 
     print("__Arc or Circle to Points___")
     points = []
-    print(poly.plane) 
-    print(poly.plane.normal) 
+    #print(poly.plane) 
+    #print(poly.plane.normal) 
     if poly.plane is None or poly.plane.normal.z == 0: normal = 1 
     else: normal = poly.plane.normal.z 
     #print(poly.plane.origin)
@@ -511,7 +515,6 @@ def speckleArcCircleToPoints(poly: Union[Arc, Circle]) -> List[Point]:
         
         pt.units = poly.plane.origin.units 
         points.append(pt)
-
     if isinstance(poly, Arc): points.append(poly.endPoint)
     return points
 

speckle_toolbox/esri/toolboxes/speckle/converter/layers/feature.py

@@ -386,11 +386,17 @@ def rasterFeatureToSpeckle(selectedLayer: arcLayer, projectCRS: arcpy.SpatialRef
             if colorizer:   
                 try: bandIndex = int(colorizer.band)
                 except: pass            
-                if rasterBandVals[bandIndex][int(count/4)] >= float(colorizer.minLabel) and rasterBandVals[bandIndex][int(count/4)] <= float(colorizer.maxLabel) : #rasterBandMinVal[bandIndex]: 
+                try:
+                    if rasterBandVals[bandIndex][int(count/4)] >= float(colorizer.minLabel) and rasterBandVals[bandIndex][int(count/4)] <= float(colorizer.maxLabel) : #rasterBandMinVal[bandIndex]: 
+                        # REMAP band values to (0,255) range
+                        valRange = float(colorizer.maxLabel) - float(colorizer.minLabel) #(rasterBandMaxVal[bandIndex] - rasterBandMinVal[bandIndex])
+                        colorVal = int( (rasterBandVals[bandIndex][int(count/4)] - float(colorizer.minLabel)) / valRange * 255 )
+                        if colorizer.invertColorRamp is True: colorVal = int( (-rasterBandVals[bandIndex][int(count/4)] + float(colorizer.maxLabel)) / valRange * 255 )
+                        color =  (colorVal<<16) + (colorVal<<8) + colorVal
+                except: # if no Min Max labels:
                     # REMAP band values to (0,255) range
-                    valRange = float(colorizer.maxLabel) - float(colorizer.minLabel) #(rasterBandMaxVal[bandIndex] - rasterBandMinVal[bandIndex])
-                    colorVal = int( (rasterBandVals[bandIndex][int(count/4)] - float(colorizer.minLabel)) / valRange * 255 )
-                    if colorizer.invertColorRamp is True: colorVal = int( (-rasterBandVals[bandIndex][int(count/4)] + float(colorizer.maxLabel)) / valRange * 255 )
+                    valRange = max(rasterBandVals[bandIndex]) - min(rasterBandVals[bandIndex]) #(rasterBandMaxVal[bandIndex] - rasterBandMinVal[bandIndex])
+                    colorVal = int( (rasterBandVals[bandIndex][int(count/4)] - min(rasterBandVals[bandIndex])) / valRange * 255 )
                     color =  (colorVal<<16) + (colorVal<<8) + colorVal
             else:
                 # REMAP band values to (0,255) range

speckle_toolbox/esri/toolboxes/speckle/speckle_arcgis.py

@@ -1,7 +1,8 @@
+
 # -*- coding: utf-8 -*-
 
 from typing import Any, Callable, List, Optional, Tuple
-r'''
+#r'''
 from collections import defaultdict
 
 import arcpy
@@ -36,7 +37,7 @@ from speckle.ui.project_vars import toolboxInputsClass, speckleInputsClass
 from speckle.converter.layers.emptyLayerTemplates import createGroupLayer
 from speckle.converter.layers.Layer import VectorLayer
 
-
+#'''
 
 def traverseObject(
         base: Base,
@@ -74,7 +75,7 @@ class Toolbox:
         .pyt file)."""
         print("___ping_Toolbox")
         self.label = "Speckle Tools"
-        self.alias = "speckle_toolbox"  
+        self.alias = "speckle_toolbox_"  
         # List of tool classes associated with this toolbox
         self.tools = [Speckle]  
         metrics.set_host_app("ArcGIS")  
@@ -331,7 +332,7 @@ class Speckle:
                                         saved_streams = self.speckleInputs.getProjectStreams()
                                         self.speckleInputs.saved_streams = saved_streams
                                         p_saved.filter.list = [f"Stream not accessible - {stream[0].stream_id}" if stream[1] is None or isinstance(stream[1], SpeckleException) else f"{stream[1].name} - {stream[1].id}" for i,stream in enumerate(saved_streams)] 
-                                        p_saved.value = p_saved.filter.list[0]
+                                        if len(p_saved.filter.list)>0: print(p_saved.filter.list); p_saved.value = p_saved.filter.list[0]
                                 break
                         p.value = None
                 par.value = False
@@ -358,7 +359,7 @@ class Speckle:
                                         saved_streams = self.speckleInputs.getProjectStreams()
                                         self.speckleInputs.saved_streams = saved_streams
                                         p_saved.filter.list = [f"Stream not accessible - {st[0].stream_id}" if st[1] is None or isinstance(st[1], SpeckleException) else f"{st[1].name} - {st[1].id}" for i,st in enumerate(saved_streams)] 
-                                        p_saved.value = p_saved.filter.list[0]
+                                        if len(p_saved.filter.list)>0: print(p_saved.filter.list); p_saved.value = p_saved.filter.list[0]
                             else: pass
 
                         p.value = None
@@ -525,8 +526,8 @@ class Speckle:
             if par.name == "streamUrl": par.value = None
             if par.name == "streamsDefalut": par.value = None
             if par.name == "savedStreams": par.value = None
-            if par.name == "branch": par.value = ""
-            if par.name == "commit": par.value = None
+            if par.name == "branch": par.value = ""; par.filter.list = []
+            if par.name == "commit": par.value = None; par.filter.list = []
             if par.name == "selectedLayers": par.value = None
             if par.name == "msg": par.value = ""
             if par.name == "action": par.value = "Send"
@@ -681,14 +682,14 @@ class Speckle:
                 if self.speckleInputs.project.activeMap.spatialReference.type == "Geographic" or self.speckleInputs.project.activeMap.spatialReference is None: #TODO test with invalid CRS
                     arcpy.AddMessage("It is advisable to set the project Spatial reference to Projected type before receiving CAD geometry (e.g. EPSG:32631), or create a custom one from geographic coordinates")
                     print("It is advisable to set the project Spatial reference to Projected type before receiving CAD geometry (e.g. EPSG:32631), or create a custom one from geographic coordinates")
-            print(f"Succesfully received {objId}")
+            print(f"Successfully received {objId}")
 
             # Clear 'latest' group
             streamBranch = streamId + "_" + self.toolboxInputs.active_branch.name + "_" + str(commit.id)
             newGroupName = f'{streamBranch}'
             
             groupExists = 0
-            #print(newGroupName)
+            print(newGroupName)
             for l in self.speckleInputs.project.activeMap.listLayers(): 
                 #print(l.longName)
                 if l.longName.startswith(newGroupName + "\\"):
@@ -697,18 +698,29 @@ class Speckle:
                     groupExists+=1
                 elif l.longName == newGroupName: 
                     groupExists+=1
+            print(newGroupName)
             if groupExists == 0:
                 # create empty group layer file 
                 path = self.speckleInputs.project.filePath.replace("aprx","gdb") #"\\".join(self.toolboxInputs.project.filePath.split("\\")[:-1]) + "\\speckle_layers\\"
-                #print(path)
-                f = open(path + "\\" + newGroupName + ".lyrx", "w")
-                content = createGroupLayer().replace("TestGroupLayer", newGroupName)
-                f.write(content)
-                f.close()
-                smth = arcpy.mp.LayerFile(path + "\\" + newGroupName + ".lyrx")
-                #print(smth)
-                layerGroup = self.speckleInputs.project.activeMap.addLayer(smth)[0]
+                print(path)
+                try:
+                    f = open(path + "\\" + newGroupName + ".lyrx", "w")
+                    content = createGroupLayer().replace("TestGroupLayer", newGroupName)
+                    f.write(content)
+                    f.close()
+                    newGroupLayer = arcpy.mp.LayerFile(path + "\\" + newGroupName + ".lyrx")
+                    layerGroup = self.speckleInputs.project.activeMap.addLayer(newGroupLayer)[0]
+                except: # for 3.0.0
+                    if self.speckleInputs.active_map is not None:
+                        layerGroup = self.speckleInputs.active_map.createGroupLayer(newGroupName)
+                    else:
+                        arcpy.AddWarning("The map didn't fully load, try refreshing the plugin.")
+                        return
+
+                print(layerGroup)
+                print("layer added")
                 layerGroup.name = newGroupName
+                print(newGroupName)
 
             if app == "QGIS" or app == "ArcGIS": check: Callable[[Base], bool] = lambda base: isinstance(base, Layer) or isinstance(base, VectorLayer) or isinstance(base, RasterLayer)
             else: check: Callable[[Base], bool] = lambda base: isinstance(base, Base)
@@ -758,6 +770,5 @@ class Speckle:
         #self.updateParameters(parameters, True)
         #self.refresh(parameters)
     
-   
-#__all__ = ["Toolbox", "Speckle"]
-'''
+    
+#__all__ = ["Toolbox", "Speckle"]