Adapter Pattern¶

The purpose is to present a client code with abstract api, rather than a number of different apis with similar goals

Favours to program abstraction rather than to concrete objects (D - Dependency Inversion)
Open Closed principle (O)
Used to convert interface of a class into one that client expects

Example

AC Adapters

Pipe Adapter

US - India Power Sockets

Also Known As the Wrapper Pattern

A program made to Print Customer Name and Address¶

Later on in project, we're asked to make it work for Vendor object
Unfortunately, currently they are different APIs - Vendor (Street and Number diff) - Customer (Combined Address Property)
Can't just copy and paste the Customer Name printer object, it would violate (DRY - Don't Repeat Yourself!)
Add some conditional logic, to handle both prints - (Worthless!)

2 Types¶

Object adapter - Composition - Can easily work with both parent and child class
Class adapter - Inheritance - It lets the Adapter override some of the classes methods

Favour Composition over Inheritance always!

It leads to flatter class structure

Easy to understand, Debug and Maintain

Object Adapter¶

In [1]:

from abc import ABCMeta, abstractproperty

In [2]:

class Customer():
    def __init__(self, name, address):
        self._name = name
        self._address = address
        
    @property
    def name(self):
        return self._name
    
    @property
    def address(self):
        return self._address

In [3]:

MOCK_CUSTOMERS = (
    Customer('Pizza Love', '33 Peperoni Lane'),
    Customer('Happy and Green', '25 Kale St.'),
    Customer('Sweet Tooth', '42 Chocolate Ave.')
)

Adaptee¶

In [4]:

class Vendor():
    def __init__(self, name, number, street):
        self._name = name
        self._number = number
        self._street = street
        
    @property
    def name(self):
        return self._name
    
    @property
    def number(self):
        return self._number
    
    @property
    def street(self):
        return self._street

Adapter¶

In [5]:

class IAdapter(metaclass=ABCMeta):
    def __init__(self, adaptee):
        self._adaptee = adaptee
        
    @property
    def adaptee(self):
        return self._adaptee
    
    @abstractproperty
    def name(self):
        pass
    
    @abstractproperty
    def address(self):
        pass

In [6]:

class VendorAdapter(IAdapter):
    @property
    def name(self):
        return self.adaptee.name
    
    @property
    def address(self):
        return f'{self.adaptee.number} {self.adaptee.street}'

Composition¶

In [7]:

MOCK_VENDORS = (
    VendorAdapter(Vendor('Dough Factory', 1, 'Semolina Court')),
    VendorAdapter(Vendor('Farm Produce', 14, 'Country Rd.')),
    VendorAdapter(Vendor('Cocoa World', 53, 'Tropical Blvd.'))
)

Print works for both Customers and Vendors¶

In [8]:

CUSTOMERS = MOCK_CUSTOMERS

for cust in CUSTOMERS:
    print(f'Name: {cust.name}, Address: {cust.address}')

Name: Pizza Love, Address: 33 Peperoni Lane
Name: Happy and Green, Address: 25 Kale St.
Name: Sweet Tooth, Address: 42 Chocolate Ave.

In [9]:

CUSTOMERS = MOCK_VENDORS

for cust in CUSTOMERS:
    print(f'Name: {cust.name}, Address: {cust.address}')

Name: Dough Factory, Address: 1 Semolina Court
Name: Farm Produce, Address: 14 Country Rd.
Name: Cocoa World, Address: 53 Tropical Blvd.

Class Adapter¶

Inherits both classes, and then modifies

In [10]:

class VendorAdapter(Vendor, Customer):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        
    @property
    def address(self):
        return f'{self.number} {self.street}'

In [11]:

MOCK_VENDORS = (
    VendorAdapter('Dough Factory', 1, 'Semolina Court'),
    VendorAdapter('Farm Produce', 14, 'Country Rd.'),
    VendorAdapter('Cocoa World', 53, 'Tropical Blvd.')
)

In [12]:

CUSTOMERS = MOCK_VENDORS

for cust in CUSTOMERS:
    print(f'Name: {cust.name}, Address: {cust.address}')

Name: Dough Factory, Address: 1 Semolina Court
Name: Farm Produce, Address: 14 Country Rd.
Name: Cocoa World, Address: 53 Tropical Blvd.

Pros and Cons¶

Object Adapter

Composition over Inheritance
Delegates to Adaptee
Works with all adaptee subclasses (If they don't change) - Open Close Principle maybe broken

Class Adapter

Subclassing
Overrides Adaptee's methods