Error implementing singleton in Python with a metaclass - python-3.x

Question

I want to implement singleton with a python metaclass.
I create two threads, instantiate the "File" class and verify that the hashcode of both is the same.
Finally I print the "_file" attribute of said class.
The objects are printed for me, but I see an error and I don't know what is the cause of it
The error is the following:
Exception in thread Thread-1:
Traceback (most recent call last):
File "/usr/lib/python3.8/threading.py", line 932, in _bootstrap_inner
self.run()
Exception in thread Thread-2:
File "/usr/lib/python3.8/threading.py", line 870, in run
Traceback (most recent call last):
File "/usr/lib/python3.8/threading.py", line 932, in _bootstrap_inner
self._target(*self._args, **self._kwargs)
TypeError: 'File' object is not callable
self.run()
File "/usr/lib/python3.8/threading.py", line 870, in run
self._target(*self._args, **self._kwargs)
TypeError: 'File' object is not callable
Object File 1 --> <__main__.File object at 0x7f7cd0575250>
Object File 2 --> <__main__.File object at 0x7f7cd0575250>
Process 1 --> <Thread(Thread-1, stopped 140174046938880)>
Process 2 --> <Thread(Thread-2, stopped 140174038546176)>
Test.py
Test.py
My code is the following:
# -*- coding: utf-8 -*-
import pathlib
import threading
from threading import Lock
class Singleton(type):
_instances = {}
_lock: Lock = Lock()
def __call__(cls, *args, **kwargs):
with cls._lock:
if cls not in cls._instances:
cls._instances[cls] = super().__call__(*args, **kwargs)
return cls._instances[cls]
class File(metaclass=Singleton):
def __init__(self):
self._file = str(pathlib.Path(__file__).name)
#property
def get_file(self):
return self._file
if __name__ == '__main__':
file_1 = File()
file_2 = File()
pro_1 = threading.Thread(target=file_1)
pro_2 = threading.Thread(target=file_2)
pro_1.start()
pro_2.start()
pro_1.join()
pro_2.join()
print("\n")
print(f"Object File 1 --> {file_1}")
print(f"Object File 2 --> {file_2}")
print("\n")
print(f"Process 1 --> {pro_1}")
print(f"Process 2 --> {pro_2}")
print("\n")
print(file_1.get_file)
print(file_2.get_file)
print("\n")

Answer 1

You error has nothing to do with the metaclass or singleton parts of the code - they are correct. Although, I should add, having a metaclass for the singleton pattern is usually overkill: although this pops out everywhere in Python related material, it is not really necessary - usually one can do away with (1) not using a singleton at all, or (2) just declaring a class, creating the needed instance in the modulenamespace, and use that instance instead of the class - and even (3) just write the singleton related logic in the __new__ method of the class itself, with no need for a metaclass at all.
Looking at your code, it seens you want to have some processing ocurring in parallel with the same file. That looks weird - but you want then a lot of workers running something that does not show up in your snippet at all. And the "singleton pattern" you tought of is just to have the instance to "support" all concurrent running threads.
So, the "singleton" part is far less important than having a self-contained thread-registry, that could take care of it for you, instead of manually calling "Thread(....)" for each instance of the class. Just associate a list or dict with your class, and implement a __getitem__ to fetch the various threads.
The way it is now, there is no sense having variables "file1", "file2" pointing to the same object- if you need several workers, just point their targets to the worker code itself.
Anyway your error is due to the fact that the "target" argument when creating a thread must be a callable: i.e. either a function, method, or an instance of a class that itself implements the __call__ method. (on the normal class, not realated at all with the __call__ in the metaclass).
There is no indication on your snippet in the question of the actual code that should be run in each thread - it is that method that should figure as the target argument to each thread.
Anyway, just do away with your singleton boilerplate that serves nothing here, and write things along this:
from threading import Thread
class File: # no metaclass needed
def __init__(self):
self.file = str(pathlib.Path(__file__).name)
self.thread = Thread(target=self.work)
self.thread.start()
def join(self):
self.thread.join()
def __call__(self):
# no-op method so that users of your class may
# "feel like" they are creating new instances.
...
def work(self):
# here comes the code that has to run in parallel in each thread:
...
File = File() # <- at once creates a single instance and hides
# the class so that new instances can't be created
# by chance.
if __name__ == '__main__':
file_1 = File() # calls the empty `__call__` on File
file_2 = File()
pro_1 = threading.Thread(target=file_1.work) # pass an actual callable as the thread target
pro_2 = threading.Thread(target=file_2.work)
pro_1.start()
...