orionis 0.410.0__tar.gz → 0.411.0__tar.gz

{orionis-0.410.0/orionis.egg-info → orionis-0.411.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orionis
-Version: 0.410.0
+Version: 0.411.0
 Summary: Orionis Framework – Elegant, Fast, and Powerful.
 Home-page: https://github.com/orionis-framework/framework
 Author: Raul Mauricio Uñate Castro

{orionis-0.410.0 → orionis-0.411.0}/orionis/metadata/framework.py

@@ -5,7 +5,7 @@
 NAME = "orionis"
 
 # Current version of the framework
-VERSION = "0.410.0"
+VERSION = "0.411.0"
 
 # Full name of the author or maintainer of the project
 AUTHOR = "Raul Mauricio Uñate Castro"

orionis-0.411.0/orionis/support/patterns/singleton/meta.py

@@ -0,0 +1,106 @@
+import threading
+import asyncio
+from typing import Dict, Type, Any, TypeVar
+
+T = TypeVar('T')
+
+class Singleton(type):
+    """
+    Thread-safe and async-safe singleton metaclass.
+
+    Ensures that only one instance of a class exists, regardless of whether the code is running in a synchronous or asynchronous context. This metaclass provides both a synchronous (`__call__`) and asynchronous (`__acall__`) method for instance creation, using appropriate locking mechanisms to prevent race conditions in multi-threaded or async environments.
+
+    Attributes
+    ----------
+    _instances : Dict[Type[T], T]
+        Stores singleton instances for each class using this metaclass.
+    _lock : threading.Lock
+        Thread lock for synchronizing instance creation in synchronous contexts.
+    _async_lock : asyncio.Lock
+        Async lock for synchronizing instance creation in asynchronous contexts.
+
+    Methods
+    -------
+    __call__(cls, *args, **kwargs)
+        Synchronously creates or retrieves the singleton instance.
+    __acall__(cls, *args, **kwargs)
+        Asynchronously creates or retrieves the singleton instance.
+    """
+
+    _instances: Dict[Type[T], T] = {}
+    _lock = threading.Lock()
+    _async_lock = asyncio.Lock()
+
+    def __call__(cls: Type[T], *args: Any, **kwargs: Any) -> T:
+        """
+        Synchronously creates or retrieves a singleton instance of the class.
+
+        This method ensures that only one instance of the class is created, even in multi-threaded environments.
+        If the instance does not exist, it acquires a thread lock to prevent race conditions, creates the instance,
+        and stores it in the class-level `_instances` dictionary. If the instance already exists, it simply returns
+        the existing instance.
+
+        Parameters
+        ----------
+        *args : Any
+            Positional arguments to pass to the class constructor.
+        **kwargs : Any
+            Keyword arguments to pass to the class constructor.
+
+        Returns
+        -------
+        T
+            The singleton instance of the class.
+        """
+
+        # Check if the instance already exists
+        if cls not in cls._instances:
+
+            # Acquire the thread lock to ensure thread safety
+            with cls._lock:
+
+                # Double-check if the instance was created while waiting for the lock
+                if cls not in cls._instances:
+
+                    # Create and store the singleton instance
+                    cls._instances[cls] = super().__call__(*args, **kwargs)
+
+        # Return the singleton instance
+        return cls._instances[cls]
+
+    async def __acall__(cls: Type[T], *args: Any, **kwargs: Any) -> T:
+        """
+        Asynchronously creates or retrieves a singleton instance of the class.
+
+        This method ensures that only one instance of the class is created, even in asynchronous contexts.
+        If the instance does not exist, it acquires an asynchronous lock to prevent race conditions,
+        creates the instance, and stores it in the class-level `_instances` dictionary. If the instance
+        already exists, it simply returns the existing instance.
+
+        Parameters
+        ----------
+        *args : Any
+            Positional arguments to pass to the class constructor.
+        **kwargs : Any
+            Keyword arguments to pass to the class constructor.
+
+        Returns
+        -------
+        T
+            The singleton instance of the class.
+        """
+
+        # Check if the instance already exists
+        if cls not in cls._instances:
+
+            # Acquire the asynchronous lock to ensure async safety
+            async with cls._async_lock:
+
+                # Double-check if the instance was created while waiting for the lock
+                if cls not in cls._instances:
+
+                    # Create and store the singleton instance
+                    cls._instances[cls] = super().__call__(*args, **kwargs)
+
+        # Return the singleton instance
+        return cls._instances[cls]

orionis-0.411.0/orionis/support/wrapper/dot_dict.py

@@ -0,0 +1,235 @@
+from typing import Any, Optional, Dict
+
+class DotDict(dict):
+
+    __slots__ = ()
+
+    def __getattr__(self, key: str) -> Optional[Any]:
+        """
+        Retrieve the value associated with the given key as an attribute.
+
+        If the value is a dictionary (but not already a DotDict), it is converted
+        to a DotDict and updated in-place. If the key does not exist, returns None.
+
+        Parameters
+        ----------
+        key : str
+            The attribute name to retrieve.
+
+        Returns
+        -------
+        Any or None
+            The value associated with the key. If the value is a dict, it is converted
+            to a DotDict before returning. Returns None if the key is not present.
+
+        Notes
+        -----
+        This method allows attribute-style access to dictionary keys. If the value
+        is a plain dictionary, it is automatically wrapped as a DotDict for consistency.
+        """
+        try:
+            value = self[key]  # Attempt to retrieve the value by key
+            # Convert plain dicts to DotDict for attribute access
+            if isinstance(value, dict) and not isinstance(value, DotDict):
+                value = DotDict(value)
+                self[key] = value  # Update the value in-place
+            return value
+        except KeyError:
+            # Return None if the key does not exist
+            return None
+
+    def __setattr__(self, key: str, value: Any) -> None:
+        """
+        Assign a value to an attribute of the DotDict instance.
+
+        This method enables attribute-style assignment for dictionary keys. If the
+        assigned value is a plain dictionary (not a DotDict), it is automatically
+        converted to a DotDict for consistency and recursive attribute access.
+
+        Parameters
+        ----------
+        key : str
+            The attribute name to assign.
+        value : Any
+            The value to assign to the attribute. If it is a dict (but not a DotDict),
+            it will be converted to a DotDict before assignment.
+
+        Returns
+        -------
+        None
+            This method does not return a value.
+
+        Notes
+        -----
+        The attribute is stored as a key-value pair in the underlying dictionary.
+        This allows seamless attribute-style access and assignment for dictionary keys.
+        """
+
+        # Convert plain dicts to DotDict for recursive attribute access
+        if isinstance(value, dict) and not isinstance(value, DotDict):
+            value = DotDict(value)
+
+        # Store the value in the underlying dictionary using the key
+        self[key] = value
+
+    def __delattr__(self, key: str) -> None:
+        """
+        Remove an attribute from the DotDict instance.
+
+        This method deletes the key-value pair corresponding to the given attribute name
+        from the underlying dictionary. If the key does not exist, an AttributeError is raised.
+
+        Parameters
+        ----------
+        key : str
+            The name of the attribute to remove.
+
+        Returns
+        -------
+        None
+            This method does not return a value.
+
+        Raises
+        ------
+        AttributeError
+            If the specified attribute does not exist in the DotDict.
+
+        Notes
+        -----
+        This method enables attribute-style deletion for dictionary keys, allowing
+        seamless removal of items using dot notation.
+        """
+        try:
+            # Attempt to delete the key from the dictionary
+            del self[key]
+        except KeyError as e:
+            # Raise AttributeError if the key is not present
+            raise AttributeError(f"'{self.__class__.__name__}' has no attribute '{key}'") from e
+
+    def get(self, key: str, default: Optional[Any] = None) -> Optional[Any]:
+        """
+        Retrieve the value associated with the given key, returning a default value if the key is not found.
+
+        If the retrieved value is a plain dictionary (not a DotDict), it is converted to a DotDict,
+        stored back in the dictionary, and then returned. This ensures consistent attribute-style access
+        for nested dictionaries.
+
+        Parameters
+        ----------
+        key : str
+            The key to look up in the dictionary.
+        default : Any, optional
+            The value to return if the key is not found. Defaults to None.
+
+        Returns
+        -------
+        Any or None
+            The value associated with the key, converted to a DotDict if it is a dict.
+            If the key is not present, returns the specified default value.
+
+        Notes
+        -----
+        This method overrides the standard dict.get() to provide automatic conversion of nested
+        dictionaries to DotDict instances, enabling recursive attribute-style access.
+        """
+        # Retrieve the value using the base dict's get method
+        value = super().get(key, default)
+        # If the value is a plain dict, convert it to DotDict for consistency
+        if isinstance(value, dict) and not isinstance(value, DotDict):
+            value = DotDict(value)
+            self[key] = value  # Store the converted value back in the dictionary
+        return value
+
+    def export(self) -> Dict[str, Any]:
+        """
+        Recursively export the contents of the DotDict as a standard Python dictionary.
+
+        This method traverses the DotDict and converts all nested DotDict instances
+        into regular dictionaries by recursively calling their `export` method.
+        Non-DotDict values are included as-is. This ensures that the returned object
+        is composed entirely of built-in Python types, making it suitable for serialization
+        or interoperability with code expecting standard dictionaries.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        result : dict
+            A dictionary representation of the DotDict, where all nested DotDict instances
+            are recursively converted to dictionaries. Non-DotDict values are returned unchanged.
+
+        Notes
+        -----
+        This method is useful for converting a DotDict (which supports attribute-style access)
+        into a plain dictionary for use with APIs, serialization, or other libraries that
+        require standard dict objects.
+        """
+        result = {}
+        # Iterate through all key-value pairs in the DotDict
+        for k, v in self.items():
+            if isinstance(v, DotDict):
+                # Recursively export nested DotDicts
+                result[k] = v.export()
+            else:
+                # Include non-DotDict values as-is
+                result[k] = v
+        return result
+
+    def copy(self) -> 'DotDict':
+        """
+        Create a deep copy of the DotDict instance, recursively copying all nested DotDict and dict objects.
+
+        This method traverses the DotDict and ensures that all nested DotDict and dict instances are
+        copied recursively, so that the returned DotDict is fully independent of the original. Non-dict
+        values are copied by reference.
+
+        Returns
+        -------
+        DotDict
+            A new DotDict instance containing a deep copy of the original contents. All nested DotDict
+            and dict objects are recursively copied, ensuring no shared references with the original.
+
+        Notes
+        -----
+        This method is useful when you need a completely independent copy of a DotDict, including all
+        nested structures, to avoid unintended side effects from shared references.
+        """
+        copied = {}
+        # Iterate through all key-value pairs in the DotDict
+        for k, v in self.items():
+            if isinstance(v, DotDict):
+                # Recursively copy nested DotDict instances
+                copied[k] = v.copy()
+            elif isinstance(v, dict):
+                # Convert plain dicts to DotDict and recursively copy
+                copied[k] = DotDict(v).copy()
+            else:
+                # Copy non-dict values by reference
+                copied[k] = v
+        # Return a new DotDict containing the copied data
+        return DotDict(copied)
+
+    def __repr__(self) -> str:
+        """
+        Return a string representation of the DotDict instance.
+
+        This method overrides the default `__repr__` implementation to provide a concise
+        and informative string that displays the class name (`DotDict`) and the contents
+        of the underlying dictionary. This is useful for debugging and logging, as it
+        clearly distinguishes DotDict objects from regular dictionaries.
+
+        Returns
+        -------
+        str
+            A string representation of the DotDict object, formatted as
+            'DotDict({...})', where {...} is the dictionary content.
+
+        Notes
+        -----
+        The returned string uses the base dictionary's representation, but is prefixed
+        with the DotDict class name for clarity.
+        """
+        # Use the base dict's __repr__ for the contents, but keep DotDict class name
+        return super().__repr__()

{orionis-0.410.0 → orionis-0.411.0/orionis.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orionis
-Version: 0.410.0
+Version: 0.411.0
 Summary: Orionis Framework – Elegant, Fast, and Powerful.
 Home-page: https://github.com/orionis-framework/framework
 Author: Raul Mauricio Uñate Castro

{orionis-0.410.0 → orionis-0.411.0}/orionis.egg-info/SOURCES.txt

@@ -532,22 +532,22 @@ tests/services/asynchrony/__init__.py
 tests/services/asynchrony/test_services_asynchrony_coroutine.py
 tests/services/environment/__init__.py
 tests/services/environment/test_services_environment.py
-tests/services/inspection/__init__.py
-tests/services/inspection/test_reflection.py
-tests/services/inspection/dependencies/__init__.py
-tests/services/inspection/dependencies/test_reflect_dependencies.py
-tests/services/inspection/dependencies/mocks/__init__.py
-tests/services/inspection/dependencies/mocks/mock_user.py
-tests/services/inspection/dependencies/mocks/mock_user_controller.py
-tests/services/inspection/dependencies/mocks/mock_users_permissions.py
-tests/services/inspection/reflection/__init__.py
-tests/services/inspection/reflection/test_reflection_abstract.py
-tests/services/inspection/reflection/test_reflection_callable.py
-tests/services/inspection/reflection/test_reflection_concrete.py
-tests/services/inspection/reflection/test_reflection_instance.py
-tests/services/inspection/reflection/test_reflection_module.py
-tests/services/inspection/reflection/mock/__init__.py
-tests/services/inspection/reflection/mock/fake_reflect_instance.py
+tests/services/introspection/__init__.py
+tests/services/introspection/test_reflection.py
+tests/services/introspection/dependencies/__init__.py
+tests/services/introspection/dependencies/test_reflect_dependencies.py
+tests/services/introspection/dependencies/mocks/__init__.py
+tests/services/introspection/dependencies/mocks/mock_user.py
+tests/services/introspection/dependencies/mocks/mock_user_controller.py
+tests/services/introspection/dependencies/mocks/mock_users_permissions.py
+tests/services/introspection/reflection/__init__.py
+tests/services/introspection/reflection/test_reflection_abstract.py
+tests/services/introspection/reflection/test_reflection_callable.py
+tests/services/introspection/reflection/test_reflection_concrete.py
+tests/services/introspection/reflection/test_reflection_instance.py
+tests/services/introspection/reflection/test_reflection_module.py
+tests/services/introspection/reflection/mock/__init__.py
+tests/services/introspection/reflection/mock/fake_reflect_instance.py
 tests/services/log/__init__.py
 tests/services/log/test_log.py
 tests/services/path/__init__.py

{orionis-0.410.0/tests/services/inspection → orionis-0.411.0/tests/services/introspection}/dependencies/mocks/mock_user_controller.py

@@ -1,5 +1,5 @@
-from tests.services.inspection.dependencies.mocks.mock_user import FakeUser
-from tests.services.inspection.dependencies.mocks.mock_users_permissions import FakeUserWithPermissions
+from tests.services.introspection.dependencies.mocks.mock_user import FakeUser
+from tests.services.introspection.dependencies.mocks.mock_users_permissions import FakeUserWithPermissions
 
 
 class UserController:

{orionis-0.410.0/tests/services/inspection → orionis-0.411.0/tests/services/introspection}/dependencies/test_reflect_dependencies.py

@@ -7,9 +7,9 @@ from orionis.services.introspection.dependencies.reflection import (
     KnownDependency
 )
 from orionis.test.cases.asynchronous import AsyncTestCase
-from tests.services.inspection.dependencies.mocks.mock_user import FakeUser
-from tests.services.inspection.dependencies.mocks.mock_user_controller import UserController
-from tests.services.inspection.dependencies.mocks.mock_users_permissions import FakeUserWithPermissions
+from tests.services.introspection.dependencies.mocks.mock_user import FakeUser
+from tests.services.introspection.dependencies.mocks.mock_user_controller import UserController
+from tests.services.introspection.dependencies.mocks.mock_users_permissions import FakeUserWithPermissions
 
 class TestReflectDependencies(AsyncTestCase):
     """
@@ -48,9 +48,9 @@ class TestReflectDependencies(AsyncTestCase):
 
         # Check resolved dependencies for 'user_repository'
         dependencies:KnownDependency = dep_user_repository
-        self.assertEqual(dependencies.module_name, 'tests.services.inspection.dependencies.mocks.mock_user')
+        self.assertEqual(dependencies.module_name, 'tests.services.introspection.dependencies.mocks.mock_user')
         self.assertEqual(dependencies.class_name, 'FakeUser')
-        self.assertEqual(dependencies.full_class_path, 'tests.services.inspection.dependencies.mocks.mock_user.FakeUser')
+        self.assertEqual(dependencies.full_class_path, 'tests.services.introspection.dependencies.mocks.mock_user.FakeUser')
         self.assertEqual(dependencies.type, FakeUser)
 
     async def testReflectionDependenciesGetMethodDependencies(self):
@@ -80,9 +80,9 @@ class TestReflectDependencies(AsyncTestCase):
         self.assertIsInstance(dep_user_permissions, KnownDependency)
 
         # Check resolved dependencies for 'user_permissions'
-        self.assertEqual(dep_user_permissions.module_name, 'tests.services.inspection.dependencies.mocks.mock_users_permissions')
+        self.assertEqual(dep_user_permissions.module_name, 'tests.services.introspection.dependencies.mocks.mock_users_permissions')
         self.assertEqual(dep_user_permissions.class_name, 'FakeUserWithPermissions')
-        self.assertEqual(dep_user_permissions.full_class_path, 'tests.services.inspection.dependencies.mocks.mock_users_permissions.FakeUserWithPermissions')
+        self.assertEqual(dep_user_permissions.full_class_path, 'tests.services.introspection.dependencies.mocks.mock_users_permissions.FakeUserWithPermissions')
         self.assertEqual(dep_user_permissions.type, FakeUserWithPermissions)
 
         # Check Instance of KnownDependency for 'permissions'

{orionis-0.410.0/tests/services/inspection → orionis-0.411.0/tests/services/introspection}/reflection/test_reflection_abstract.py

@@ -1,6 +1,6 @@
 from orionis.services.introspection.abstract.reflection import ReflectionAbstract
 from orionis.services.introspection.dependencies.entities.class_dependencies import ClassDependency
-from tests.services.inspection.reflection.mock.fake_reflect_instance import AbstractFakeClass
+from tests.services.introspection.reflection.mock.fake_reflect_instance import AbstractFakeClass
 from orionis.test.cases.asynchronous import AsyncTestCase
 
 class TestServiceReflectionAbstract(AsyncTestCase):
@@ -27,7 +27,7 @@ class TestServiceReflectionAbstract(AsyncTestCase):
         """
         reflect = ReflectionAbstract(AbstractFakeClass)
         module_name = reflect.getModuleName()
-        self.assertEqual(module_name, 'tests.services.inspection.reflection.mock.fake_reflect_instance')
+        self.assertEqual(module_name, 'tests.services.introspection.reflection.mock.fake_reflect_instance')
 
     async def testGetModuleWithClassName(self):
         """
@@ -35,7 +35,7 @@ class TestServiceReflectionAbstract(AsyncTestCase):
         """
         reflect = ReflectionAbstract(AbstractFakeClass)
         module_with_class_name = reflect.getModuleWithClassName()
-        self.assertEqual(module_with_class_name, 'tests.services.inspection.reflection.mock.fake_reflect_instance.AbstractFakeClass')
+        self.assertEqual(module_with_class_name, 'tests.services.introspection.reflection.mock.fake_reflect_instance.AbstractFakeClass')
 
     async def testGetDocstring(self):
         """

{orionis-0.410.0/tests/services/inspection → orionis-0.411.0/tests/services/introspection}/reflection/test_reflection_concrete.py

@@ -1,6 +1,6 @@
 from orionis.services.introspection.concretes.reflection import ReflectionConcrete
 from orionis.services.introspection.dependencies.entities.class_dependencies import ClassDependency
-from tests.services.inspection.reflection.mock.fake_reflect_instance import FakeClass
+from tests.services.introspection.reflection.mock.fake_reflect_instance import FakeClass
 from orionis.test.cases.asynchronous import AsyncTestCase
 
 class TestServiceReflectionConcrete(AsyncTestCase):
@@ -44,11 +44,11 @@ class TestServiceReflectionConcrete(AsyncTestCase):
         """
         Tests that the getModuleName method of the ReflectionConcrete class returns the correct module name
         for the provided FakeClass. Asserts that the returned module name matches the expected string
-        'tests.services.inspection.reflection.mock.fake_reflect_instance'.
+        'tests.services.introspection.reflection.mock.fake_reflect_instance'.
         """
         reflect = ReflectionConcrete(FakeClass)
         module_name = reflect.getModuleName()
-        self.assertEqual(module_name, 'tests.services.inspection.reflection.mock.fake_reflect_instance')
+        self.assertEqual(module_name, 'tests.services.introspection.reflection.mock.fake_reflect_instance')
 
     async def testGetModuleWithClassName(self):
         """
@@ -57,11 +57,11 @@ class TestServiceReflectionConcrete(AsyncTestCase):
 
         Asserts:
             The returned string matches the expected module path and class name:
-            'tests.services.inspection.reflection.mock.fake_reflect_instance.FakeClass'
+            'tests.services.introspection.reflection.mock.fake_reflect_instance.FakeClass'
         """
         reflect = ReflectionConcrete(FakeClass)
         module_with_class_name = reflect.getModuleWithClassName()
-        self.assertEqual(module_with_class_name, 'tests.services.inspection.reflection.mock.fake_reflect_instance.FakeClass')
+        self.assertEqual(module_with_class_name, 'tests.services.introspection.reflection.mock.fake_reflect_instance.FakeClass')
 
     async def testGetDocstring(self):
         """

{orionis-0.410.0/tests/services/inspection → orionis-0.411.0/tests/services/introspection}/reflection/test_reflection_instance.py

@@ -1,5 +1,5 @@
 from orionis.services.introspection.dependencies.entities.class_dependencies import ClassDependency
-from tests.services.inspection.reflection.mock.fake_reflect_instance import FakeClass
+from tests.services.introspection.reflection.mock.fake_reflect_instance import FakeClass
 from orionis.services.introspection.instances.reflection import ReflectionInstance
 from orionis.test.cases.asynchronous import AsyncTestCase
 
@@ -43,11 +43,11 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
         Asserts:
             The returned module name matches the expected string
-            'tests.services.inspection.reflection.mock.fake_reflect_instance'.
+            'tests.services.introspection.reflection.mock.fake_reflect_instance'.
         """
         reflect = ReflectionInstance(FakeClass())
         module_name = reflect.getModuleName()
-        self.assertEqual(module_name, 'tests.services.inspection.reflection.mock.fake_reflect_instance')
+        self.assertEqual(module_name, 'tests.services.introspection.reflection.mock.fake_reflect_instance')
 
     async def testGetModuleWithClassName(self):
         """
@@ -59,7 +59,7 @@ class TestServiceReflectionInstance(AsyncTestCase):
         """
         reflect = ReflectionInstance(FakeClass())
         module_with_class_name = reflect.getModuleWithClassName()
-        self.assertEqual(module_with_class_name, 'tests.services.inspection.reflection.mock.fake_reflect_instance.FakeClass')
+        self.assertEqual(module_with_class_name, 'tests.services.introspection.reflection.mock.fake_reflect_instance.FakeClass')
 
     async def testGetDocstring(self):
         """

{orionis-0.410.0/tests/services/inspection → orionis-0.411.0/tests/services/introspection}/reflection/test_reflection_module.py

@@ -4,7 +4,7 @@ from orionis.services.introspection.exceptions import ReflectionTypeError, Refle
 
 class TestServiceReflectionModule(AsyncTestCase):
 
-    module_name = 'tests.services.inspection.reflection.mock.fake_reflect_instance'
+    module_name = 'tests.services.introspection.reflection.mock.fake_reflect_instance'
 
     async def testGetModule(self):
         """

orionis-0.411.0/tests/support/patterns/singleton/test_patterns_singleton.py

@@ -0,0 +1,40 @@
+from orionis.support.patterns.singleton import Singleton
+from orionis.test.cases.asynchronous import AsyncTestCase
+
+class TestPatternsSingleton(AsyncTestCase):
+
+    async def testSingleton(self):
+        """
+        Tests the behavior of the Singleton metaclass.
+
+        Validates that a class using the Singleton metaclass only ever creates a single instance,
+        regardless of how many times it is instantiated. Also checks that the initial state of the
+        singleton instance remains unchanged after subsequent instantiations.
+
+        Parameters
+        ----------
+        self : TestPatternsSingleton
+            The test case instance.
+
+        Returns
+        -------
+        None
+            This method does not return any value. Assertions are used to verify singleton behavior.
+
+        """
+        # Define a class using the Singleton metaclass
+        class SingletonClass(metaclass=Singleton):
+            def __init__(self, value):
+                self.value = value
+
+        # Create the first instance of SingletonClass
+        instance1 = SingletonClass(1)
+
+        # Attempt to create a second instance with a different value
+        instance2 = SingletonClass(2)
+
+        # Assert that both instances are actually the same object
+        self.assertIs(instance1, instance2)
+
+        # Assert that the value remains as set by the first instantiation
+        self.assertEqual(instance1.value, 1)