Creating a set of Python classes

Question

I have a class representing a Request. I have a set of very specific requests such as "I-95", "P-22", etc. which perform distinct functions and are called by a controller class. What is the best way to do this so that one could add more requests easily down the road?

I have something like this at the moment:

class Requests:
    def __init__(self):
            self.types = [
                    'I-95',
                    'P-22',
                    ...
            ]

    def generate_request(self,type, Data):
            # Here I would call the appropriate case for the type, e.g. P-22

A Request case would be in its own separate file and look like this:

class P-22:
    # Members
    def __init__(self, Data):
        # Set data members
    def request(self):
        # Submit request

And I would be able to create a request in the controller

f = Requests()
f.generate_request('RC75')

I'm striving for something that's as clean and easily extendable as possible. Thank you!

Well for starters I'd like to implement something akin to an enum with the list of request types. A key value pair dictionary perhaps with the name of the request as the key and a pointer to its functions as its value. — Connor Spangler, Jun 10 '16 at 19:23

Elwin Arens · Accepted Answer · 2016-06-12T13:55:33.493

Try something like:

class BaseRequest:
    name = None


class FooRequest(BaseRequest):
    name = 'I-95'

    def response(self):
        return "foo"


class BarRequest(BaseRequest):
    name = 'P-22'

    def response(self):
        return "bar"


class RequestManager:

    def __init__(self):
        self.requests = {
            FooRequest.name: FooRequest,
            BarRequest.name: BarRequest
        }

    def generate_request(self, name):
        if name in self.requests:
            return self.requests[name]()

    def register_request(self, request_class):
        assert issubclass(request_class, BaseRequest), \
            'Request class not a subclass of BaseRequest'
        assert hasattr('name', request_class) and isinstance(request_class.name, str), \
            'Request name not correctly configured'
        self.requests[request_class.name] = request_class

And then:

manager = RequestManager()
request = manager.generate_request('I-95')
if request is not None:
    print(request.response()) # "foo"

And for registering new requests:

class NewRequest(BaseRequest):
    name = 'N-1'

    def response(self):
        return "new"

manager = RequestManager()
manager.register_request(NewRequest)
request = manager.generate_request('N-1')
if request is not None:
    print(request.response()) # "new"

I personally think this is better done using a Singleton-pattern for the RequestManager (untested!):

class RequestManager:

    instance = None

    class __RequestManager:
        requests = {
            FooRequest.name: FooRequest,
            BarRequest.name: BarRequest
        }

        def generate_request(self, name):
            if name in self.requests:
                return self.requests[name]()

        def register_request(self, request_class):
            assert issubclass(request_class, BaseRequest), \
                'Request class not a subclass of BaseRequest'
            assert hasattr('name', request_class) and isinstance(request_class.name, str), \
                'Request name not correctly configured'
            self.requests[request_class.name] = request_class

    def __new__(cls):
        if not cls.instance:
            cls.instance = cls.__RequestManager()
        return cls.instance

    @staticmethod
    def getInstance():
        return RequestManager()

This creates a statically accessible RequestManager instance:

manager = RequestManager.getInstance()
# Rest same as before, register some requests, etc.

manager2 = RequestManager.getInstance() # This is actually the same manager ie. the same instance!

manager and manager2 share the same requests dictionary, so updates via one of them applies to both (technically speaking to the same manager, because you retrieve the same instance twice)

Another question: I want a developer to be able to write a case file of their own, and add it to something like a package which contains all case files. How could I do that without them having to explicitly add the new file to the imports. I'd like for them only to have to add the file and add a new line with the name and function pointer — Connor Spangler, Jun 10 '16 at 19:26
Great thank you. Can you explain how the Singleton-pattern could be applied to this scenario? I'm definitely interested in the concept. — Connor Spangler, Jun 10 '16 at 19:46
So if I make a change to manager then manager2 will also change? — Connor Spangler, Jun 10 '16 at 20:20
Yes, they are the same instance, so modifications apply to both. — Elwin Arens, Jun 10 '16 at 20:21
I'm getting an error - AttributeError: Requests instance has no attribute "generate_request" — Connor Spangler, Jun 13 '16 at 13:53
It looks similar to what the answer for this question is referring to: http://stackoverflow.com/questions/1301346/the-meaning-of-a-single-and-a-double-underscore-before-an-object-name-in-python — Connor Spangler, Jun 13 '16 at 13:56

Creating a set of Python classes

1 Answers1