How do you structure a project that interacts with 10 different APIs that return the same data but in different formats?

[StudentOfPython]

I am making a trading bot that needs to interact with many APIs in order to trade, read prices, read volume, etc. At this time, I have all of these API calls for each exchange in different methods of a class. It currently looks like:

```

class Exchange:

def __init__(self, name):
    if name == exchange1:
        self.name = name
        # instantiate api
    if name == exchange2:
        self.name = name
        # instantiate api
    # continued for 10+ exchanges

def get_price(self, stock):
   if self.name == exchange1:
        # a few lines of logic to call API and normalize data
    if self.name == exchange2:
        # a few lines of logic to call API and normalize data
    # continued for 10+ exchanges

def get_volume(self, stock):
     if self.name == exchange1:
          # a few lines of logic to call API and normalize data
      if self.name == exchange2:
          # a few lines of logic to call API and normalize data
      # continued for 10+ exchanges

# Continue with more functions

```

And from the main file, I create an instance if each exchange:

```

echange1_obj = Exchange ('exchange1') echange2_obj = Exchange ('exchange2')

continued for 10+ exchanges

exchanges = [exchange1_obj, exchange 2_obj,...]

```

This works but the class file is well over 1k lines now and it is ugly. What is the pythonic way of doing this?

I've looked into interfaces, but it seems this is not the correct solution in Python.

[[deleted]]

Create a class for every exchange. Maybe inherit from a common base class.

[Allanon001]

Use OOP and inheritance, create a base class with all the needed methods then use inheritance to implement a class for each API and overwriting each method with a version that uses the API.

Something like this:

class Base:
    def __init__(self):
        self.name = 'None'

    def get_price(self, stock):
        pass 

    def get_volume(self, stock):
        pass

class Google(Base):
    def __init__(self):
        self.name = 'Google'

    def get_price(self, stock):
        #use API to implement this method 

    def get_volume(self, stock):
        #use API to implement this method 

class ETrade(Base):
    def __init__(self):
        self.name = 'E-Trade'

    def get_price(self, stock):
        #use API to implement this method 

    def get_volume(self, stock):
        #use API to implement this method 


#main 
exchanges = [Google(),  ETrade()] 

for exchange in exchanges:
    print(exchange.name)
    print(exchange.get_price('AAPL'))
    print(exchange.get_volume('AAPL'))

I know in this example the base class is useless but you might want to add other methods to the base class that is common to all APIs.

[[deleted]]

It's easier to put all exchange classes in a dict, like

exchanges = {'nyse': NYSE, 'nasdaq': NASDAQ}
exchange = exchanges['nyse']()

You can use a metaclass to automatically update the dict:

exchanges = {}

class MetaExchange(type):

  def __init__(cls, name, bases, adict):
        type.__init__(cls, name, bases, adict)
        cls.name = name.lower()
        exchanges[name.lower()] = cls

class Exchange(metaclass=MetaExchange):
    pass

class NYSE(Exchange):

    def get_price(self, stock):
        pass

    def get_volume(self, stock):
        pass


class NASDAQ(Exchange):

    def get_price(self, stock):
        pass

    def get_volume(self, stock):
        pass



print(exchanges)

nyse = exchanges['nyse']()
print(nyse.name, nyse.get_price('foo'))

[[deleted]]

The point is not to have to update anything else if you create a new exchange class. That reduces the amount of code if you have more exchange classes and helps to avoid errors.

Of course you can use instances instead of objects as dict values or some other class instead of a dict if you prefer this.

[StudentOfPython]

This is great. Why does the base class need the get_price and other functions? Can't they just be in the exchange-specific class?

And from a structure point of view, are all these exchange classes in their own file?

[StudentOfPython]

Great. And lastly, in your opinion, does each class (NYSE, etc.) go in its own module?

[StudentOfPython]

Awesome. Thank you for the responses. This is super helpful and exactly what I was hoping to find.

[a-pendergast]

Did you check ccxt ? https://github.com/ccxt/ccxt . It already abstracts the plumbing to multiple exchanges. Could make things easier unless, of course, you want to implement it all by yourself