Prevent other classes' methods from calling my constructor

Question

How do I make a python "constructor" "private", so that the objects of its class can only be created by calling static methods? I know there are no C++/Java like private methods in Python, but I'm looking for another way to prevent others from calling my constructor (or other method).

I have something like:

class Response(object):
    @staticmethod
    def from_xml(source):
        ret = Response()
        # parse xml into ret            
        return ret

    @staticmethod
    def from_json(source):
        # parse json
        pass

and would like the following behavior:

r = Response() # should fail
r = Response.from_json(source) # should be allowed

The reason for using static methods is that I always forget what arguments my constructors take - say JSON or an already parsed object. Even then, I sometimes forget about the static methods and call the constructor directly (not to mention other people using my code). Documenting this contract won't help with my forgetfulness. I'd rather enforce it with an assertion.

And contrary to some of the commenters, I don't think this is unpythonic - "explicit is better than implicit", and "there should be only one way to do it".

How can I get a gentle reminder when I'm doing it wrong? I'd prefer a solution where I don't have to change the static methods, just a decorator or a single line drop-in for the constructor would be great. A la:

class Response(object):
    def __init__(self):
        assert not called_from_outside()

Answer 1

I think this is what you're looking for - but it's kind of unpythonic as far as I'm concerned.

class Foo(object):
    def __init__(self):
        raise NotImplementedError()

    def __new__(cls):
        bare_instance = object.__new__(cls)
        # you may want to have some common initialisation code here
        return bare_instance


    @classmethod
    def from_whatever(cls, arg):
        instance = cls.__new__(cls)
        instance.arg = arg
        return instance

Given your example (from_json and from_xml), I assume you're retrieving attribute values from either a json or xml source. In this case, the pythonic solution would be to have a normal initializer and call it from your alternate constructors, i.e.:

class Foo(object):
    def __init__(self, arg):
        self.arg = arg

    @classmethod
    def from_json(cls, source):
        arg = get_arg_value_from_json_source(source)
        return cls(arg)

    @classmethod
    def from_xml(cls, source):
        arg = get_arg_value_from_xml_source(source)
        return cls(arg)

Oh and yes, about the first example: it will prevent your class from being instantiated in the usual way (calling the class), but the client code will still be able to call on Foo.__new__(Foo), so it's really a waste of time. Also it will make unit testing harder if you cannot instantiate your class in the most ordinary way... and quite a few of us will hate you for this.

Answer 2

I'd recommend turning the factory methods into module-level factory functions, then hiding the class itself from users of your module.

def one_constructor(source):
    return _Response(...)

def another_constructor(source):
    return _Response(...)

class _Response(object):
    ...

You can see this approach used in modules like re, where match objects are only constructed through functions like match and search, and the documentation doesn't actually name the match object type. (At least, the 3.4 documentation doesn't. The 2.7 documentation incorrectly refers to re.MatchObject, which doesn't exist.) The match object type also resists direct construction:

>>> type(re.match('',''))()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: cannot create '_sre.SRE_Match' instances

but unfortunately, the way it does so relies upon the C API, so it's not available to ordinary Python code.

Answer 3

Good discussion in the comments.

For the minimal use case you describe,

class Response(object):

    def __init__(self, construct_info = None):
        if construct_info is None: raise ValueError, "must create instance using from_xml or from_json"
        # etc

    @staticmethod
    def from_xml(source):
         info = {}  # parse info into here
         return Response(info)

    @staticmethod
    def from_json(source):
         info = {}  # parse info into here
         return Response(info)

It can be gotten around by a user who passes in a hand-constructed info, but at that point they'll have to read the code anyway and the static method will provide the path of least resistance. You can't stop them, but you can gently discourage them. It's Python, after all.

Answer 4

This might be achievable through metaclasses, but is heavily discouraged in Python. Python is not Java. There is no first-class notion of public vs private in Python; the idea is that users of the language are "consenting adults" and can use methods however they like. Generally, functions that are intended to be "private" (as in not part of the API) are denoted by a single leading underscore; however, this is mostly just convention and there's nothing stopping a user from using these functions.

In your case, the Pythonic thing to do would be to default the constructor to one of the available from_foo methods, or even to create a "smart constructor" that can find the appropriate parser for most cases. Or, add an optional keyword arg to the __init__ method that determines which parser to use.

Answer 5

An alternative API (and one I've seen far more in Python APIs) if you want to keep it explicit for the user would be to use keyword arguments:

class Foo(object):
    def __init__(self, *, xml_source=None, json_source=None):
        if xml_source and json_source:
            raise ValueError("Only one source can be given.")
        elif xml_source:
            from_xml(xml_source)
        elif json_source:
            from_json(json_source)
        else:
            raise ValueError("One source must be given.")

Here using 3.x's * to signify keyword-only arguments, which helps enforce the explicit API. In 2.x this is recreatable with kwargs.

Naturally, this doesn't scale well to lots of arguments or options, but there are definitely cases where this style makes sense. (I'd argue bruno desthuilliers probably has it right for this case, from what we know, but I'll leave this here as an option for others).

Answer 6

The following is similar to what I ended up doing. It is a bit more general then what was asked in the question.

I made a function called guard_call, that checks if the current method is being called from a method of a certain class.

This has multiple uses. For example, I used the Command Pattern to implement undo and redo, and used this to ensure that my objects were only ever modified by command objects, and not random other code (which would make undo impossible).

In this concrete case, I place a guard in the constructor ensuring only Response methods can call it:

class Response(object):
    def __init__(self):
        guard_call([Response])
        pass

    @staticmethod
    def from_xml(source):
        ret = Response()
        # parse xml into ret
        return ret

For this specific case, you could probably make this a decorator and remove the argument, but I didn't do that here.

Here is the rest of the code. It's been a long time since I tested it, and can't guarentee that it works in all edge cases, so beware. It is also still Python 2. Another caveat is that it is slow, because it uses inspect. So don't use it in tight loops and when speed is an issue, but it might be useful when correctness is more important than speed.

Some day I might clean this up and release it as a library - I have a couple more of these functions, including one that asserts you are running on a particular thread. You may snear at the hackishness (it is hacky), but I did find this technique useful to smoke out some hard to find bugs, and to ensure my code still behaves during refactorings, for example.

from __future__ import print_function
import inspect

# http://stackoverflow.com/a/2220759/143091        
def get_class_from_frame(fr):
    args, _, _, value_dict = inspect.getargvalues(fr)
    # we check the first parameter for the frame function is
    # named 'self'
    if len(args) and args[0] == 'self':
        # in that case, 'self' will be referenced in value_dict
        instance = value_dict.get('self', None)
        if instance:
            # return its class
            return getattr(instance, '__class__', None)
    # return None otherwise
    return None

def guard_call(allowed_classes, level=1):
    stack_info = inspect.stack()[level + 1]
    frame = stack_info[0]
    method = stack_info[3]
    calling_class = get_class_from_frame(frame)
    # print ("calling class:", calling_class)
    if calling_class:
        for klass in allowed_classes:
            if issubclass(calling_class, klass):
                return

    allowed_str = ", ".join(klass.__name__ for klass in allowed_classes)
    filename = stack_info[1]
    line = stack_info[2]
    stack_info_2 = inspect.stack()[level]
    protected_method = stack_info_2[3]
    protected_frame = stack_info_2[0]
    protected_class = get_class_from_frame(protected_frame)

    if calling_class:
        origin = "%s:%s" % (calling_class.__name__, method)
    else:
        origin = method

    print ()
    print ("In %s, line %d:" % (filename, line))
    print ("Warning, call to %s:%s was not made from %s, but from %s!" %
           (protected_class.__name__, protected_method, allowed_str, origin))
    assert False

r = Response() # should fail
r = Response.from_json("...") # should be allowed