Name conflicts

compositor/operator.py

@@ -2,17 +2,18 @@
 
 from bpy.types import Node, CompositorNodeColorBalance, CompositorNodeTree
 
-from ..ntp_operator import NTP_Operator
+from ..ntp_operator import NTP_Operator, INDEX
 from ..ntp_node_tree import NTP_NodeTree
 from ..utils import *
 from io import StringIO
 from .node_settings import compositor_node_settings
 
-SCENE_VAR = "scene"
-BASE_NAME_VAR = "base_name"
-END_NAME_VAR = "end_name"
+SCENE = "scene"
+BASE_NAME = "base_name"
+END_NAME = "end_name"
+NODE = "node"
 
-ntp_vars = {SCENE_VAR, BASE_NAME_VAR, END_NAME_VAR} 
+comp_op_reserved_names = {SCENE, BASE_NAME, END_NAME, NODE} 
 
 class NTPCompositorOperator(NTP_Operator):
     bl_idname = "node.ntp_compositor"
@@ -33,42 +34,44 @@ class NTPCompositorOperator(NTP_Operator):
     def __init__(self):
         super().__init__()
         self._settings = compositor_node_settings
+        for name in comp_op_reserved_names:
+            self._used_vars[name] = 0
 
 
     def _create_scene(self, indent: str):
         #TODO: wrap in more general unique name util function
         self._write(f"# Generate unique scene name", indent)
-        self._write(f"{BASE_NAME_VAR} = {str_to_py_str(self.compositor_name)}",
+        self._write(f"{BASE_NAME} = {str_to_py_str(self.compositor_name)}",
                     indent)
-        self._write(f"{END_NAME_VAR} = {BASE_NAME_VAR}", indent)
-        self._write(f"if bpy.data.scenes.get({END_NAME_VAR}) != None:", indent)
+        self._write(f"{END_NAME} = {BASE_NAME}", indent)
+        self._write(f"if bpy.data.scenes.get({END_NAME}) != None:", indent)
 
         indent2 = f"{indent}\t"
-        self._write(f"i = 1", indent2)
-        self._write(f"{END_NAME_VAR} = {BASE_NAME_VAR} + f\".{{i:03d}}\"", 
+        self._write(f"{INDEX} = 1", indent2)
+        self._write(f"{END_NAME} = {BASE_NAME} + f\".{{i:03d}}\"", 
                     indent2)
-        self._write(f"while bpy.data.scenes.get({END_NAME_VAR}) != None:",
+        self._write(f"while bpy.data.scenes.get({END_NAME}) != None:",
                     indent2)
 
         indent3 = f"{indent}\t\t"
-        self._write(f"{END_NAME_VAR} = {BASE_NAME_VAR} + f\".{{i:03d}}\"", indent3)
-        self._write(f"i += 1\n", indent3)
+        self._write(f"{END_NAME} = {BASE_NAME} + f\".{{{INDEX}:03d}}\"", indent3)
+        self._write(f"{INDEX} += 1\n", indent3)
 
-        self._write(f"{SCENE_VAR} = bpy.context.window.scene.copy()\n", indent) 
-        self._write(f"{SCENE_VAR}.name = {END_NAME_VAR}", indent)
-        self._write(f"{SCENE_VAR}.use_fake_user = True", indent)
-        self._write(f"bpy.context.window.scene = {SCENE_VAR}", indent)
+        self._write(f"{SCENE} = bpy.context.window.scene.copy()\n", indent) 
+        self._write(f"{SCENE}.name = {END_NAME}", indent)
+        self._write(f"{SCENE}.use_fake_user = True", indent)
+        self._write(f"bpy.context.window.scene = {SCENE}", indent)
 
     def _initialize_compositor_node_tree(self, ntp_nt, nt_name):
         #initialize node group
         self._write(f"#initialize {nt_name} node group", self._outer)
         self._write(f"def {ntp_nt.var}_node_group():", self._outer)
 
         if ntp_nt.node_tree == self._base_node_tree:
-            self._write(f"{ntp_nt.var} = {SCENE_VAR}.node_tree")
+            self._write(f"{ntp_nt.var} = {SCENE}.node_tree")
             self._write(f"#start with a clean node tree")
-            self._write(f"for node in {ntp_nt.var}.nodes:")
-            self._write(f"\t{ntp_nt.var}.nodes.remove(node)")
+            self._write(f"for {NODE} in {ntp_nt.var}.nodes:")
+            self._write(f"\t{ntp_nt.var}.nodes.remove({NODE})")
         else:
             self._write((f"{ntp_nt.var} = bpy.data.node_groups.new("
                          f"type = \'CompositorNodeTree\', "

geometry/operator.py

@@ -2,20 +2,22 @@
 from bpy.types import GeometryNode, GeometryNodeTree
 from bpy.types import Node
 
-if bpy.app.version >= (3, 6, 0):
-    from bpy.types import GeometryNodeSimulationInput
-    from bpy.types import GeometryNodeSimulationOutput
-if bpy.app.version >= (4, 0, 0):
-    from bpy.types import GeometryNodeRepeatInput
-    from bpy.types import GeometryNodeRepeatOutput
-
 from io import StringIO
 
 from ..ntp_operator import NTP_Operator
 from ..utils import *
 from .node_tree import NTP_GeoNodeTree
 from .node_settings import geo_node_settings
 
+ITEM = "item"
+OBJECT_NAME = "name"
+OBJECT = "obj"
+MODIFIER = "mod"
+geo_op_reserved_names = {ITEM, 
+                         OBJECT_NAME, 
+                         OBJECT,
+                         MODIFIER}
+
 class NTPGeoNodesOperator(NTP_Operator):
     bl_idname = "node.ntp_geo_nodes"
     bl_label = "Geo Nodes to Python"
@@ -34,6 +36,8 @@ class NTPGeoNodesOperator(NTP_Operator):
     def __init__(self):
         super().__init__()
         self._settings = geo_node_settings
+        for name in geo_op_reserved_names:
+            self._used_vars[name] = 0
 
     if bpy.app.version >= (3, 6, 0):
         def _process_zone_output_node(self, node: GeometryNode) -> None:
@@ -50,15 +54,14 @@ def _process_zone_output_node(self, node: GeometryNode) -> None:
             node_var = self._node_vars[node]
 
             self._write(f"# Remove generated {items}")
-            self._write(f"for item in {node_var}.{items}:")
+            self._write(f"for {ITEM} in {node_var}.{items}:")
             self._write(f"\t{node_var}.{items}.remove(item)")
 
             for i, item in enumerate(getattr(node, items)):
                 socket_type = enum_to_py_str(item.socket_type)
                 name = str_to_py_str(item.name)
                 self._write(f"# Create item {name}")
-                self._write(f"{node_var}.{items}.new"
-                            f"({socket_type}, {name})")
+                self._write(f"{node_var}.{items}.new({socket_type}, {name})")
                 if is_sim:
                     item_var = f"{node_var}.{items}[{i}]"
                     ad = enum_to_py_str(item.attribute_domain)
@@ -199,14 +202,14 @@ def _process_node_tree(self, node_tree: GeometryNodeTree) -> None:
 
     def _apply_modifier(self, nt: GeometryNodeTree, nt_var: str):
         #get object
-        self._write(f"name = bpy.context.object.name", self._outer)
-        self._write(f"obj = bpy.data.objects[name]", self._outer)
+        self._write(f"{OBJECT_NAME} = bpy.context.object.name", self._outer)
+        self._write(f"{OBJECT} = bpy.data.objects[{OBJECT_NAME}]", self._outer)
 
         #set modifier to the one we just created
         mod_name = str_to_py_str(nt.name)
-        self._write(f"mod = obj.modifiers.new(name = {mod_name}, "
+        self._write(f"{MODIFIER} = obj.modifiers.new(name = {mod_name}, "
                     f"type = 'NODES')", self._outer)
-        self._write(f"mod.node_group = {nt_var}", self._outer)
+        self._write(f"{MODIFIER}.node_group = {nt_var}", self._outer)
 
 
     def execute(self, context):

material/operator.py

@@ -10,6 +10,8 @@
 from .node_settings import shader_node_settings
 
 MAT_VAR = "mat"
+NODE = "node"
+shader_op_reserved_names = {MAT_VAR, NODE}
 
 class NTPMaterialOperator(NTP_Operator):
     bl_idname = "node.ntp_material"
@@ -22,6 +24,8 @@ class NTPMaterialOperator(NTP_Operator):
     def __init__(self):
         super().__init__()
         self._settings = shader_node_settings
+        for name in shader_op_reserved_names:
+            self._used_vars[name] = 0
 
     def _create_material(self, indent: str):
         self._write(f"{MAT_VAR} = bpy.data.materials.new("
@@ -44,8 +48,8 @@ def _initialize_shader_node_tree(self, ntp_node_tree: NTP_NodeTree,
         if ntp_node_tree.node_tree == self._base_node_tree:
             self._write(f"{ntp_node_tree.var} = {MAT_VAR}.node_tree")
             self._write(f"#start with a clean node tree")
-            self._write(f"for node in {ntp_node_tree.var}.nodes:")
-            self._write(f"\t{ntp_node_tree.var}.nodes.remove(node)")
+            self._write(f"for {NODE} in {ntp_node_tree.var}.nodes:")
+            self._write(f"\t{ntp_node_tree.var}.nodes.remove({NODE})")
         else:
             self._write((f"{ntp_node_tree.var} = bpy.data.node_groups.new("
                          f"type = \'ShaderNodeTree\', "