Add Singleton pattern implementation with tests and configuration

Author: AntoineBuirey

makefile

@@ -1,7 +1,7 @@
 
 VERSION = $(shell python get_version.py)
 
-MODULES = cache colors config http_code version
+MODULES = cache colors config http_code version singleton
 
 TARGETS = $(addprefix dist/,$(addsuffix -$(VERSION).tar.gz,$(MODULES)))
 TARGETS += $(addprefix dist/,$(addsuffix -$(VERSION)-py3-none-any.whl,$(MODULES)))
@@ -29,4 +29,4 @@ tests: $(addprefix tests/,$(MODULES))
 
 clean:
 	rm -rf dist
-	rm -rf **/*.egg-info **/build
+	rm -rf **/*.egg-info **/build

singleton/pyproject.toml

@@ -0,0 +1,22 @@
+[project]
+name = "singleton"
+dynamic = ["version"]
+description = "Singleton pattern implementation in Python"
+authors = [
+    { name = "Antoine BUIREY", email = "antoine.buirey@gmail.com" }
+]
+requires-python = ">=3.10"
+
+[tool.setuptools.packages.find]
+include = [
+    "singleton"
+]
+
+[tool.pytest.ini_options]
+minversion = "8.0"
+testpaths = [
+    "tests"
+]
+python_files = [
+    "*tests.py"
+]

singleton/setup.py

@@ -0,0 +1,11 @@
+"""
+Setup script for the package, used by setuptools to build and install the package.
+"""
+
+import os
+
+from setuptools import setup
+
+setup(
+    version=os.environ.get("PACKAGE_VERSION", "0.0.0-dev")
+)

singleton/singleton/__init__.py

@@ -0,0 +1 @@
+from .singleton import Singleton

singleton/singleton/singleton.py

@@ -0,0 +1,17 @@
+
+
+class Singleton:
+    """
+    A implementation of Singleton pattern.
+    This class ensures that only one instance of the class is created.
+    """
+
+    __instance : 'Singleton' = None
+
+    def __new__(cls, *args, **kwargs):
+        """
+        Create a new instance of the class if it doesn't exist, otherwise return the existing instance.
+        """
+        if not cls.__instance:
+            cls.__instance = super(Singleton, cls).__new__(cls)
+        return cls.__instance

singleton/tests/singleton_tests.py

@@ -0,0 +1,101 @@
+from singleton.singleton.singleton import Singleton
+import pytest
+
+
+@pytest.mark.parametrize(
+    "args, kwargs",
+    [
+        ((), {}),
+        ((1,), {}),
+        (("foo", 42), {}),
+        ((), {"a": 1},),
+        ((1, 2), {"a": 3, "b": 4}),
+    ],
+    ids = ["no_args", "single_arg", "multiple_args", "no_args_with_kwargs", "multiple_args_with_kwargs"]
+)
+def test_singleton_instance_uniqueness(args, kwargs):
+    # Arrange
+
+    # Act
+    instance1 = Singleton(*args, **kwargs)
+    instance2 = Singleton(*args, **kwargs)
+
+    # Assert
+    assert instance1 is instance2
+    assert isinstance(instance1, Singleton)
+    assert isinstance(instance2, Singleton)
+
+def test_singleton_instance_is_singleton_across_different_args():
+    # Arrange
+
+    # Act
+    instance1 = Singleton(1, 2, a=3)
+    instance2 = Singleton("foo", bar="baz")
+
+    # Assert
+    assert instance1 is instance2
+
+def test_singleton_instance_is_singleton_across_no_args_and_args():
+    # Arrange
+
+    # Act
+    instance1 = Singleton()
+    instance2 = Singleton(123)
+    instance3 = Singleton(a="b")
+
+    # Assert
+    assert instance1 is instance2
+    assert instance2 is instance3
+
+
+def test_singleton_instance_is_not_none():
+    # Arrange
+
+    # Act
+    instance = Singleton()
+
+    # Assert
+    assert instance is not None
+
+def test_singleton_instance_reset_for_test(monkeypatch):
+    # Arrange
+    monkeypatch.setattr(Singleton, "_Singleton__instance", None)
+
+    # Act
+    instance1 = Singleton()
+    instance2 = Singleton()
+
+    # Assert
+    assert instance1 is instance2
+    assert Singleton._Singleton__instance is instance1
+
+@pytest.mark.parametrize(
+    "pre_existing_instance, expected_new_instance",
+    [
+        (None, True),
+        ("dummy", False),
+    ],
+    ids=["no_pre_existing_instance", "pre_existing_instance"]
+)
+def test_singleton_new_branch_coverage(monkeypatch, pre_existing_instance, expected_new_instance):
+    # Arrange
+    monkeypatch.setattr(Singleton, "_Singleton__instance", pre_existing_instance)
+
+    # Act
+    instance = Singleton()
+
+    # Assert
+    if expected_new_instance:
+        assert isinstance(instance, Singleton)
+    else:
+        assert instance == pre_existing_instance
+
+def test_singleton_direct_class_attribute_access():
+    # Arrange
+
+    # Act
+    instance = Singleton()
+    class_instance = Singleton._Singleton__instance
+
+    # Assert
+    assert instance is class_instance