AARD-1687: Save exporter options with active design

exporter/SynthesisFusionAddin/proto/deps.py

@@ -1,13 +1,15 @@
 import os
-import platform, subprocess
+import platform
+import logging
 from pathlib import Path
 
-from src.general_imports import INTERNAL_ID;
+from src.general_imports import INTERNAL_ID
 
 import adsk.core, adsk.fusion
 
 system = platform.system()
 
+
 def getPythonFolder() -> str:
     """Retreives the folder that contains the Autodesk python executable
 
@@ -21,19 +23,23 @@
     # Thank you Kris Kaplan
     import sys
     import importlib.machinery
-    osPath = importlib.machinery.PathFinder.find_spec('os', sys.path).origin
+
+    osPath = importlib.machinery.PathFinder.find_spec("os", sys.path).origin
 
     # The location of the python executable is found relative to the location of the os module in each operating system
     if system == "Windows":
         pythonFolder = Path(osPath).parents[1]
     elif system == "Darwin":
-        pythonFolder = f'{Path(osPath).parents[2]}/bin'
+        pythonFolder = f"{Path(osPath).parents[2]}/bin"
     else:
-        raise ImportError('Unsupported platform! This add-in only supports windows and macos')
-
-    logging.getLogger(f'{INTERNAL_ID}').debug(f'Python Folder -> {pythonFolder}')
+        raise ImportError(
+            "Unsupported platform! This add-in only supports windows and macos"
+        )
+
+    logging.getLogger(f"{INTERNAL_ID}").debug(f"Python Folder -> {pythonFolder}")
     return pythonFolder
 
+
 def executeCommand(command: tuple) -> int:
     """Abstracts the execution of commands to account for platform differences
 
@@ -43,20 +49,14 @@
     Returns:
         int: Exit code of the process
     """
-    if system == "Windows":
-        executionResult = subprocess.call(
-            command,
-            bufsize=1,
-            creationflags=subprocess.CREATE_NO_WINDOW,
-            shell=False
-        )
-    else:
-        # Uses os.system because I was unable to get subprocess.call to work on MacOS
-        installComm = str.join(' ', command)
-        executionResult = os.system(installComm)
+
+    joinedCommand = str.join(" ", command)
+    logging.getLogger(f"{INTERNAL_ID}").debug(f"Command -> {joinedCommand}")
+    executionResult = os.system(joinedCommand)
 
     return executionResult
 
+
 def installCross(pipDeps: list) -> bool:
     """Attempts to fetch pip script and resolve dependencies with less user interaction
 
@@ -89,25 +89,48 @@
     try:
         pythonFolder = getPythonFolder()
     except ImportError as e:
-        logging.getLogger(f'{INTERNAL_ID}').error(f'Failed to download dependencies: {e.msg}')
+        logging.getLogger(f"{INTERNAL_ID}").error(
+            f"Failed to download dependencies: {e.msg}"
+        )
         return False
 
     if system == "Darwin":  # macos
-
         # if nothing has previously fetched it
-        if (not os.path.exists(f'{pythonFolder}/get-pip.py')) :
-            executeCommand(['curl', 'https://bootstrap.pypa.io/get-pip.py', '-o', f'"{pythonFolder}/get-pip.py"'])
+        if not os.path.exists(f"{pythonFolder}/get-pip.py"):
+            executeCommand(
+                [
+                    "curl",
+                    "https://bootstrap.pypa.io/get-pip.py",
+                    "-o",
+                    f'"{pythonFolder}/get-pip.py"',
+                ]
+            )
 
         executeCommand([f'"{pythonFolder}/python"', f'"{pythonFolder}/get-pip.py"'])
 
+    pythonExecutable = 'python'
+    if system == "Windows":
+        pythonExecutable = 'python.exe'
+
     for depName in pipDeps:
         progressBar.progressValue += 1
         progressBar.message = f"Installing {depName}..."
         adsk.doEvents()
+
         # os.path.join needed for varying system path separators
-        installResult = executeCommand([f"\"{os.path.join(pythonFolder, 'python')}\"", '-m', 'pip', 'install', depName])
+        installResult = executeCommand(
+            [
+                f"\"{os.path.join(pythonFolder, pythonExecutable)}\"",
+                "-m",
+                "pip",
+                "install",
+                depName,
+            ]
+        )
         if installResult != 0:
-            logging.getLogger(f'{INTERNAL_ID}').warn(f'Dep installation "{depName}" exited with code "{installResult}"')
+            logging.getLogger(f"{INTERNAL_ID}").warn(
+                f'Dep installation "{depName}" exited with code "{installResult}"'
+            )
 
     if system == "Darwin":
         pipAntiDeps = ["dataclasses", "typing"]
@@ -117,9 +140,20 @@
             progressBar.message = f"Uninstalling {depName}..."
             progressBar.progressValue += 1
             adsk.doEvents()
-            uninstallResult = executeCommand([f"\"{os.path.join(pythonFolder, 'python')}\"", '-m', 'pip', 'uninstall', f'{depName}', '-y'])
+            uninstallResult = executeCommand(
+                [
+                    f"\"{os.path.join(pythonFolder, pythonExecutable)}\"",
+                    "-m",
+                    "pip",
+                    "uninstall",
+                    f"{depName}",
+                    "-y",
+                ]
+            )
             if uninstallResult != 0:
-                logging.getLogger(f'{INTERNAL_ID}').warn(f'AntiDep uninstallation "{depName}" exited with code "{uninstallResult}"')
+                logging.getLogger(f"{INTERNAL_ID}").warn(
+                    f'AntiDep uninstallation "{depName}" exited with code "{uninstallResult}"'
+                )
 
     progressBar.hide()
 
@@ -132,6 +166,7 @@
 def _checkDeps() -> bool:
     try:
         from .proto_out import joint_pb2, assembly_pb2, types_pb2, material_pb2
+
         return True
     except ImportError:
         return False

exporter/SynthesisFusionAddin/src/Parser/ExporterOptions.py

@@ -0,0 +1,179 @@
+"""
+Container for all options pertaining to the Fusion Exporter.
+These options are saved per-design and are passed to the parser upon design export.
+"""
+
+import os
+import json
+import platform
+from typing import get_origin
+from enum import Enum, EnumType
+from dataclasses import dataclass, fields, field
+import adsk.core
+
+from adsk.fusion import CalculationAccuracy, TriangleMeshQualityOptions
+
+from ..strings import INTERNAL_ID
+
+# Not 100% sure what this is for - Brandon
+JointParentType = Enum("JointParentType", ["ROOT", "END"])
+
+WheelType = Enum("WheelType", ["STANDARD", "OMNI"])
+SignalType = Enum("SignalType", ["PWM", "CAN", "PASSIVE"])
+ExportMode = Enum("ExportMode", ["ROBOT", "FIELD"])  # Dynamic / Static export
+PreferredUnits = Enum("PreferredUnits", ["METRIC", "IMPERIAL"])
+
+
+@dataclass
+class Wheel:
+    jointToken: str = field(default=None)
+    wheelType: WheelType = field(default=None)
+    signalType: SignalType = field(default=None)
+
+
+@dataclass
+class Joint:
+    jointToken: str = field(default=None)
+    parent: JointParentType = field(default=None)
+    signalType: SignalType = field(default=None)
+    speed: float = field(default=None)
+    force: float = field(default=None)
+
+
+@dataclass
+class Gamepiece:
+    occurrenceToken: str = field(default=None)
+    weight: float = field(default=None)
+    friction: float = field(default=None)
+
+
+class PhysicalDepth(Enum):
+    # No Physical Properties are generated
+    NoPhysical = 0
+
+    # Only Body Physical Objects are generated
+    Body = 1
+
+    # Only Occurrence that contain Bodies and Bodies have Physical Properties
+    SurfaceOccurrence = 2
+
+    # Every Single Occurrence has Physical Properties even if empty
+    AllOccurrence = 3
+
+
+class ModelHierarchy(Enum):
+    # Model exactly as it is shown in Fusion 360 in the model view tree
+    FusionAssembly = 0
+
+    # Flattened Assembly with all bodies as children of the root object
+    FlatAssembly = 1
+
+    # A Model represented with parented objects that are part of a jointed tree
+    PhysicalAssembly = 2
+
+    # Generates the root assembly as a single mesh and stores the associated data
+    SingleMesh = 3
+
+
+@dataclass
+class ExporterOptions:
+    fileLocation: str = field(default=(os.getenv("HOME") if platform.system() == "Windows" else os.path.expanduser("~")))
+    name: str = field(default=None)
+    version: str = field(default=None)
+    materials: int = field(default=0)
+    exportMode: ExportMode = field(default=ExportMode.ROBOT)
+    wheels: list[Wheel] = field(default=None)
+    joints: list[Joint] = field(default=None)
+    gamepieces: list[Gamepiece] = field(default=None)
+    preferredUnits: PreferredUnits = field(default=PreferredUnits.IMPERIAL)
+
+    # Always stored in kg regardless of 'preferredUnits'
+    robotWeight: float = field(default=0.0)
+
+    compressOutput: bool = field(default=True)
+    exportAsPart: bool = field(default=False)
+
+    hierarchy: ModelHierarchy = field(default=ModelHierarchy.FusionAssembly)
+    visualQuality: TriangleMeshQualityOptions = field(
+        default=TriangleMeshQualityOptions.LowQualityTriangleMesh
+    )
+    physicalDepth: PhysicalDepth = field(default=PhysicalDepth.AllOccurrence)
+    physicalCalculationLevel: CalculationAccuracy = field(
+        default=CalculationAccuracy.LowCalculationAccuracy
+    )
+
+    def readFromDesign(self) -> None:
+        designAttributes = adsk.core.Application.get().activeProduct.attributes
+        for field in fields(self):
+            attribute = designAttributes.itemByName(INTERNAL_ID, field.name)
+            if attribute:
+                setattr(
+                    self,
+                    field.name,
+                    self._makeObjectFromJson(field.type, json.loads(attribute.value)),
+                )
+
+        return self
+
+    def writeToDesign(self) -> None:
+        designAttributes = adsk.core.Application.get().activeProduct.attributes
+        for field in fields(self):
+            data = json.dumps(
+                getattr(self, field.name),
+                default=lambda obj: (
+                    obj.value
+                    if isinstance(obj, Enum)
+                    else (
+                        {
+                            key: (
+                                lambda value: (
+                                    value if not isinstance(value, Enum) else value.value
+                                )
+                            )(value)
+                            for key, value in obj.__dict__.items()
+                        }
+                        if hasattr(obj, "__dict__")
+                        else obj
+                    )
+                ),
+                indent=4,
+            )
+            designAttributes.add(INTERNAL_ID, field.name, data)
+
+    # There should be a way to clean this up - Brandon
+    def _makeObjectFromJson(self, objectType: type, data: any) -> any:
+        primitives = (bool, str, int, float, type(None))
+        if isinstance(objectType, EnumType):
+            return objectType(data)
+        elif (
+            objectType in primitives or type(data) in primitives
+        ):  # Required to catch `fusion.TriangleMeshQualityOptions`
+            return data
+        elif get_origin(objectType) is list:
+            return [
+                self._makeObjectFromJson(objectType.__args__[0], item) for item in data
+            ]
+
+        newObject = objectType()
+        attrs = [
+            x
+            for x in dir(newObject)
+            if not x.startswith("__") and not callable(getattr(newObject, x))
+        ]
+        for attr in attrs:
+            currType = objectType.__annotations__.get(attr, None)
+            if get_origin(currType) is list:
+                setattr(
+                    newObject,
+                    attr,
+                    [
+                        self._makeObjectFromJson(currType.__args__[0], item)
+                        for item in data[attr]
+                    ],
+                )
+            elif currType in primitives:
+                setattr(newObject, attr, data[attr])
+            elif isinstance(currType, object):
+                setattr(newObject, attr, self._makeObjectFromJson(currType, data[attr]))
+
+        return newObject