I learning Python (coming from a dotnet background) and developing an app which interacts with a webservice. 

The web service is flat, in that it has numerous calls some of which are related to sessions e.g. logging on etc, whereas other calls are related to retrieving/setting business data.

To accompany the webservice, there are a couple of python classes which wrap all the calls. I am looking to develop a client on top of that class but give the client more OO structure.

The design of my own app was to have a Session-type class which would be responsible for logging on/maintaining the connection etc , but itself would be injected into a Business-type class which is responsible for making all the business calls.

So the stack is something like

```
WebService          (Soap)   
 WebServiceWrapper  (Python)
  Session           (Python)
   Business         (Python)

```

Here's a sample of my code (I've renamed some methods to try and make stuff more explicit)

```
from webServiceWrapper import webServiceAPI

class Session():
    def __init__(self, user, password):
        self._api = webServiceAPI()
        self.login = self._api.login(user, password) 

    def webServiceCalls(self):
        return self._api()

class Business():
    def __init__(self, service):
        self._service=service

    def getBusinessData(self):
        return self._service.get_business_data()

```

and my unit test 

```
class exchange(unittest.TestCase):
    def setUp(self):
        self.service = Session("username","password")
        self._business = Business(self.service.webServiceCalls())

    def testBusinessReturnsData(self):
        self.assertFalse(self._business.getBusinessData()==None)

```

The unit test fails fails on

```
return self._api() 

```

saying that the underlying class is not callable

```
TypeError: 'webServiceAPI' is not callable

```

My first q is, is that the python way? Is the OO thinking which underpins app development with static languages good for dynamic as well? (That's probably quite a big q!)

My second q is that, if this kind of architecture is ok, what am I doing wrong (I guess in terms of passing references to objects in this way)?

Many thx

S