VSCodeTools using td typings from interpreter if TD version available

Author: function-store

Diff for: FunctionStore_tools_2023.code-workspace

@@ -1 +1,11 @@
-{"folders": [{"path": "."}]}
+{
+    "folders": [
+        {
+            "path": "."
+        }
+    ],
+    "settings": {
+        "python.defaultInterpreterPath": "C:\\Program Files\\Derivative\\TouchDesigner.2023.32139\\bin\\python.exe",
+        "python.terminal.activateEnvironment": true
+    }
+}

Diff for: modules/release/FunctionStore_tools_2023.tox

@@ -1,7 +1,7 @@
 '''Info Header Start
 Name : extStubser
 Author : Dan@DAN-4090
-Saveorigin : FunctionStore_tools_2023.334.toe
+Saveorigin : FunctionStore_tools_2023.416.toe
 Saveversion : 2023.11600
 Info Header End'''
 import ast
@@ -37,12 +37,37 @@ def _parse_td_version(self, path: Path) -> tuple[int, int] | None:
 
 	def _is_valid_td_version(self, version: tuple[int, int] | None) -> bool:
 		"""Check if version meets minimum requirements (>= 2023.3000)."""
-		return version is not None and version >= (2023, 3000)
+		if version is None:
+			return False
+		major, minor = version
+		if major > 2023:
+			return True
+		elif major == 2023:
+			return minor >= 30000
+		return False
 
 	def _find_td_builtins(self) -> Path | None:
 		"""Search for valid __builtins__.pyi in the highest version TD installation."""
-		# Start from current TD installation folder
-		current_td = Path(app.binFolder).parent
+		# First check current app version
+		current_td = Path(app.installFolder)
+		version = self._parse_td_version(current_td)
+		debug(f"Current TD version: {version}")
+		
+		# Always check if current builtins exists
+		td_builtins = current_td / 'bin' / '__builtins__.pyi'
+		if td_builtins.exists():
+			if self._is_valid_td_version(version):
+				debug(f"Using current TD builtins in {version[0]}.{version[1]}")
+				return td_builtins
+			else:
+				debug("Current TD version is not valid, but builtins exists")
+				# Store current builtins as fallback
+				current_builtins = td_builtins
+		else:
+			current_builtins = None
+			debug("Current TD builtins not found")
+		
+		# If current version is not valid, search for highest version
 		td_installations = current_td.parent
 		highest_match = None
 		highest_version = (0, 0)
@@ -59,7 +84,8 @@ def _find_td_builtins(self) -> Path | None:
 					highest_match = td_builtins
 					debug(f"Found builtins in TD {version[0]}.{version[1]}")
 
-		return highest_match
+		# Return highest valid version if found, otherwise return current builtins
+		return highest_match if highest_match else current_builtins
 
 	def _get_typing_paths(self, name: str) -> tuple[Path, Path]:
 		"""Determine paths for builtins and stubs files."""
@@ -69,7 +95,7 @@ def _get_typing_paths(self, name: str) -> tuple[Path, Path]:
 			if td_builtins:
 				builtins_file = td_builtins
 			else:
-				debug("No valid TD installation (>= 2023.3000) found with __builtins__.pyi")
+				debug("No valid TD installation (>= 2023.30000) found with __builtins__.pyi")
 				# Fallback to local typings
 				builtins_file = Path("typings", "__builtins__.pyi")
 		else:

Diff for: modules/release/OpenVSCode.tox

@@ -111,12 +111,49 @@ def OpenVSCode(self):
 		# Ensure workspace file exists, create if necessary
 		project_folder = Path(project.folder)
 		workspace_path = project_folder / self.workspace
+		
+		# Get the interpreter path
+		interpreter_path = self._get_interpreter_path()
+		
+		# Load existing workspace config or create new one
+		if workspace_path.exists():
+			with workspace_path.open('r') as file:
+				workspace_config = json.load(file)
+		else:
+			workspace_config = {"folders": [{"path": "."}]}
+		
+		# Initialize settings if it doesn't exist
+		if "settings" not in workspace_config:
+			workspace_config["settings"] = {}
+		
+		# Update Python settings to force workspace interpreter
+		python_settings = {
+			"python.defaultInterpreterPath": str(interpreter_path),
+			"python.terminal.activateEnvironment": True
+		}
+		
+		# Update workspace settings
+		workspace_config["settings"].update(python_settings)
+		
+		# Save the workspace config
+		with workspace_path.open('w') as file:
+			json.dump(workspace_config, file, indent=4)
+		
 		if not workspace_path.exists():
-			with workspace_path.open('w') as file:
-				json.dump({"folders": [{"path": "."}]}, file)
 			self.logger.Log(f"Created workspace file: {workspace_path}")
-			if TDTypings := getattr(op, FNS_TDTYPINGS, None):
+		else:
+			self.logger.Log(f"Updated interpreter path in workspace file: {workspace_path}")
+		
+		# Check if we're using a valid TD interpreter or falling back to local typings
+		interpreter_parent = interpreter_path.parent
+		version = self._parse_td_version(interpreter_parent.parent)
+		
+		# Only deploy stubs if we're not using a valid TD interpreter
+		if not self._is_valid_td_version(version):
+			if TDTypings := getattr(op, 'FNS_TDTYPINGS', None):
+				self.logger.Log("Deploying stubs because no valid TD interpreter found")
 				TDTypings.DeployStubs()
+			
 		missing_workspace = not self.workspace or not Path(self.workspace).exists()
 
 		if missing_exe or missing_workspace:
@@ -144,3 +181,77 @@ def _popErrorMessage(self, missing_exe=False, missing_workspace=False):
 			ui.messageBox("Error", message, buttons=["OK"])
 			self.ownerComp.openParameters()
 		pass
+
+	def _parse_td_version(self, path: Path) -> tuple[int, int] | None:
+		"""Extract TouchDesigner version from path."""
+		td_pattern = re.compile(r'TouchDesigner\.(\d+)\.(\d+)')
+		# Check folder name for version
+		match = td_pattern.match(path.name)
+		if match:
+			return (int(match.group(1)), int(match.group(2)))
+		return None
+
+	def _is_valid_td_version(self, version: tuple[int, int] | None) -> bool:
+		"""Check if version meets minimum requirements (>= 2023.3000)."""
+		if version is None:
+			return False
+		major, minor = version
+		if major > 2023:
+			return True
+		elif major == 2023:
+			return minor >= 30000
+		return False
+
+	def _find_td_interpreter(self) -> Path | None:
+		"""Search for valid python.exe in the highest version TD installation."""
+		# First check current app version
+		current_td = Path(app.installFolder)
+		version = self._parse_td_version(current_td)
+		self.logger.Log(f"Current TD version: {version}")
+		
+		# Always check if current interpreter exists
+		td_interpreter = current_td / 'bin' / 'python.exe'
+		if td_interpreter.exists():
+			if self._is_valid_td_version(version):
+				self.logger.Log(f"Using current TD interpreter in {version[0]}.{version[1]}")
+				return td_interpreter
+			else:
+				self.logger.Log("Current TD version is not valid, but interpreter exists")
+				# Store current interpreter as fallback
+				current_interpreter = td_interpreter
+		else:
+			current_interpreter = None
+			self.logger.Log("Current TD interpreter not found")
+		
+		# If current version is not valid, search for highest version
+		td_installations = current_td.parent
+		highest_match = None
+		highest_version = (0, 0)
+
+		for td_folder in td_installations.iterdir():
+			if not td_folder.is_dir():
+				continue
+
+			version = self._parse_td_version(td_folder)
+			if self._is_valid_td_version(version) and version > highest_version:
+				td_interpreter = td_folder / 'bin' / 'python.exe'
+				if td_interpreter.exists():
+					highest_version = version
+					highest_match = td_interpreter
+					self.logger.Log(f"Found interpreter in TD {version[0]}.{version[1]}")
+
+		# Return highest valid version if found, otherwise return current interpreter
+		return highest_match if highest_match else current_interpreter
+
+	def _get_interpreter_path(self) -> Path:
+		"""Determine paths for builtins and stubs files."""
+		# Try to find builtins in highest version TD installation
+		td_interpreter = self._find_td_interpreter()
+		if td_interpreter:
+			interpreter_file = td_interpreter
+		else:
+			self.logger.Log("No valid TD installation (>= 2023.3000) found with python.exe")
+			# Fallback to local typings
+			interpreter_file = Path("typings", "python.exe")
+
+		return interpreter_file