Question: Simple addon template :

```
import bpy

bl_info = {
    "name": "test",
    "author": "me",
    "version": (1, 0),
    "blender" : (2, 80, 0),
    "location": "",
    "warning": "",
    "wiki_url": "",
    "tracker_url": "",
    "category": ""
}

class OBJECT_OT_CustomOp(bpy.types.Operator):
    """Tooltip"""
    bl_idname = "object.test"
    bl_label = "test"

    def execute(self, context):

        None

        return {'FINISHED'}

addon_keymaps = []

def register():
    bpy.utils.register_class(OBJECT_OT_CustomOp)

def unregister():
    bpy.utils.unregister_class(OBJECT_OT_CustomOp)

if __name__ == "__main__":
    register()

```

My question is about that class name (-> **OBECT\_OT\_CustomOp**). I just want to know : Whatever name it is , can i really re-use it for other customop/addon ? since i've tried to use that same class name for different op and it doesn't conflict. Everything works fine, because that customop is unregistered when i exit the tool ? But will it break at some point ?

Answer: 
**Same class name is not an issue.**

when a register-able class is registered it is added to `bpy.types` with a name generated from the `bl_idname`.

eg

```
class Foo(bpy.types.Operator):
    bl_idname = "object.test"

```

if succesfully registered will be known to blender as the class

```
bpy.types.OBJECT_OT_test

```

*or similarly after running question code in text editor (`__main__` thread)* The OT stands for "Operator Type", similarly PT and MT are Panels and Menus respectively.

```
>>> bpy.types.OBJECT_OT_test
<class '__main__.OBJECT_OT_CustomOp'>

>>> bpy.ops.object.test.idname()
'OBJECT_OT_test'

>>> bpy.ops.object.test.idname_py()
'object.test'

```

Can also import it as a module from text block, and run the register method. This is, IMO, a better way to test simple addon code in blender as it gives the option to unregister, since the classes are no longer "lost" in the **main** thread. Find Link

```
>>> myaddon = D.texts['Text'].as_module()
>>> myaddon.register()
>>> bpy.types.OBJECT_OT_test
<class 'Text.OBJECT_OT_CustomOp'>

```

So has now re-registered the operator, this time belonging to the "Text" module.
Having a variable the same name in the scope of its own module is no issue. Having another matching `bl_idname` will overwrite the one registered previously.

Would either stick to naming convention and

```
class OBJECT_OT_test(...):
    bl_idname = "object.test"

```

or not at all

```
class TestOperator(...):
    bl_idname = "object.test"

```

whereas feel question's `OBJECT_OT_CustomOp` is some hickly-dy pickle-dy in-between sort or arrangement.
Got a quick test over different situation:

1. register same `class name` same `bl_idname`:

Blender will overwrite existing operator mapping (`bl_idname` → initiate same python class)
2. register different `class name` with same `bl_idname`:

Still, Blender overwrites existing operator due to `bl_idname` overwritten, this cause all operators registered before using same `bl_idname` replaced by new one(there should be only one, of course)
3. register same `class name` with different `bl_idname`:

Blender does not complain about duplicate class name since it works only on `bl_idname`, the new operator with same class name will work concurrently with the previous one. Both can be access by different **`bl_idname`**.

Since the test is done in text editor, each **run** has it's own scope, local name will not affect each other. So you are free to "reuse name".

On the other hand, the `register()` will map a `bl_idname` to an operator class, use that class *object* to do operation when user call an operator. IIRC the object is registered in separated place (RNA meta) and it shouldn't conflict with name either you assign a new operator to original operator.

e.g.

```
#  Code:
import io_mesh_uv_layout  # UV layout exporter ops
io_mesh_uv_layout = OBJECT_OT_add_object  # random ops from template

# Execute UV layout exporter → Original UV export operator

```

Not sure if there is any mistake in this discussion