How to create a class which can be initialized by its own instance

Task:

Implement some class that accepts at least one argument and can be either initialized by original data, or its own instance.

Minimal example of usage:

arg = {}  # whatever necessary for the real object
instance1 = NewClass(arg)
instance2 = NewClass(instance1)
assert instance2 is instance1  # or at least, ==

More complex example of usage:

from typing import Mapping, Union


class NewClass:
    """
    Incomplete

    Should somehow act like described in the task

    """
    def __init__(self, data: Mapping):
        self.data = data

    def cool_method(self):
        assert isinstance(self.data, Mapping)
        # do smth with self.data
        return ...

    ...


class AnotherClass:
    """
    Accepts both mappings and NewClass instances,
    but needs NewClass internally

    """
    def __init__(self, obj: Union[Mapping, NewClass]):
        self.cool = NewClass(obj).cool_method()
        ...

One just have to make use of the __new__ method on the class, instead of __init__ to be able to change what is instantiated.

In this case, all you need is to write your NewClass like this:

from typing import Union, Mapping, Self

class NewClass:
    """
    acts like described in the task

    """
    # typing.Self is available in Python 3.11. 
    # For previous versions, just put the class name quoted
    # in a string: `"NewClass"` instead of `Self`
    def __new__(cls, data: Union[Mapping, Self]):
        if isinstance(data, NewClass):
            return data
        self = super().__new__(cls)
        self.data = data
        return self 

    def cool_method(self):
        assert isinstance(self.data, Mapping)
        # do smth with self.data
        return ...

Avoiding a metaclass is interesting because it avoid metaclasses conflicts, in larger projects, and it is an abstraction level most
projects simply does not need. Actually, static type checkers such
as "Mypy" can't even figure out behavior changes coded into
the metaclasses.

On the other hand, __new__ is a common special method sibling to __init__, readily available, just not used more commonly because Python also provides
__init__, which suffices when the default behavior of __new__, of
always creating a new instance, is not the desired one.

For some reason I do not know, making use of a metaclass to create a "singleton" got wildly popular in tutorials and answers. It is a design pattern much less important and less used in Python than in languages which do not allow "stand alone" functions. Metaclasses are not needed for singletons either, by the way - one can just create a top-level instance of whatever class should have a single instance, and use that instance from that point on, instead of creating new instances. Other languages also restrict the existence of top-level, importable, instances, making that a need that was artificially imported into Python.

Metaclass solution:

Actual for python 3.8

class SelfWrapperMeta(type):
    """
    Metaclass, allowing to return previously created user class instance,
    if the user class init receives it as the first positional argument
    
    Other arguments are just ignored in that self-wrapping case
    
    Otherwise, the user class init calls normally

    """
    def __call__(cls, arg, /, *args, **kwargs):
        if isinstance(arg, cls):
            return arg
        return super().__call__(arg, *args, **kwargs)

Example of usage:

class A(metaclass=SelfWrapperMeta):
    def __init__(self, data):
        self.data = data

example = {}
a = A(example)
b = A(a)
c = A(example)
assert a is b
assert c is not a

Subclass dict

If subclassing dict is acceptable then a very trivial solution can be used:

class MyDict(dict):
    pass

d = {1: 2}
d1 = MyDict(d)
d2 = MyDict(d1)

Because MyDict is a subclass of dict then:

• Comparisons to another instance of MyDict or dict, will behave the same as if it was dict to dict for == and is. The nice thing about that is that it follows the least surprise principle
• MyDict is considered a Mapping type

Modify __init__

Here's a few options for "doing something" to data, mixing and matching may be required for your solution.

Data Not Modified

You may be just logging a MyDict creation:

class MyDict(dict):
    def __init__(self, data: Mapping):
        if isinstance(data, MyDict):
            print(f'Making MyDict with {data}')
        super().__init__(data)

Data Modified

If a key/value is being injected and the requirement is they compare True then one can reason you want that injection back ported to the data arg. (It's arguable that this is surprising behaviour and therefore not a good idea)

class MyDict(dict):
    def __init__(self, data: Mapping):
        data['_debug_entry'] = 'involved in making MyDict instance'
        super().__init__(data)