new_contents: '''
  Adafruit compatible using BaseGPIO class to represent a PCA9555 IO expander
  Copyright (C) 2016 Matias Vidal
  Ported from: https://github.com/dberlin/PCA95XX
  
  # Copyright 2012 Daniel Berlin
  
  Permission is hereby granted, free of charge, to any person obtaining a copy of
  this software and associated documentation files (the "Software"), to deal in
  the Software without restriction, including without limitation the rights to
  use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
  of the Software, and to permit persons to whom the Software is furnished to do
  so, subject to the following conditions:
  
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
  
  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  SOFTWARE.'''
  
  import Adafruit_GPIO as GPIO
  import Adafruit_GPIO.I2C as I2C
  
  # For the PCA 953X and 955X series, the chips with 8 GPIO's have these port numbers
  # The chips with 16 GPIO's have the first port for each type at double these numbers
  # IE The first config port is 6
  
  INPUT_PORT = 0
  OUTPUT_PORT = 1
  POLARITY_PORT = 2
  CONFIG_PORT = 3
  
  IN = GPIO.IN
  OUT = GPIO.OUT
  HIGH = GPIO.HIGH
  LOW = GPIO.LOW
  
  
  class PCA9555(GPIO.BaseGPIO):
      """Class to represent a PCA9555  GPIO extender. Compatible
      with the Adafruit_GPIO BaseGPIO class so it can be used as a custom GPIO
      class for interacting with device.
      """
      NUM_GPIO = 16
  
      def __init__(self, address=0x20, busnum=None, i2c=None, num_gpios=16, **kwargs):
          address = int(address)
          self.__name__ = "PCA955"
          # Create I2C device.
          i2c = i2c or I2C
          busnum = busnum or i2c.get_default_bus()
          self._device = i2c.get_i2c_device(address, busnum, **kwargs)
          self.num_gpios = num_gpios
          
          if self.num_gpios <= 8:
              self.iodir = self._device.readU8(CONFIG_PORT)
              self.outputvalue = self._device.readU8(OUTPUT_PORT)
  
          elif self.num_gpios > 8 and self.num_gpios <= 16:
              self.iodir = self._device.readU16(CONFIG_PORT<< 1)
              self.outputvalue = self._device.readU16(OUTPUT_PORT << 1)
  
      def _changebit(self, bitmap, bit, value):
          assert value == 1 or value == 0, "Value is %s must be 1 or 0" % value
          if value == 0:
              return bitmap & ~(1 << bit)
          elif value == 1:
              return bitmap | (1 << bit)
  
      # Change the value of bit PIN on port PORT to VALUE.  If the
      # current pin state for the port is passed in as PORTSTATE, we
      # will avoid doing a read to get it.  The port pin state must be
      # complete if passed in (IE it should not just be the value of the
      # single pin we are trying to change)
      def _readandchangepin(self, port, pin, value, portstate = None):
          assert pin >= 0 and pin < self.num_gpios, "Pin number %s is invalid, only 0-%s are valid" % (pin, self.num_gpios)
          if not portstate:
            if self.num_gpios <= 8:
               portstate = self._device.readU8(port)
            elif self.num_gpios > 8 and self.num_gpios <= 16:
               portstate = self._device.readU16(port << 1)
          newstate = self._changebit(portstate, pin, value)
          if self.num_gpios <= 8:
              self._device.write8(port, newstate)
          else:
              self._device.write16(port << 1, newstate)
          return newstate
  
      # Polarity inversion
      def polarity(self, pin, value):
          return self._readandchangepin(POLARITY_PORT, pin, value)
  
      # Pin direction
      def config(self, pin, mode):
          self.iodir = self._readandchangepin(CONFIG_PORT, pin, mode, self.iodir)
          return self.iodir
  
      def output(self, pin, value):
          assert self.iodir & (1 << pin) == 0, "Pin %s not set to output" % pin
          self.outputvalue = self._readandchangepin(OUTPUT_PORT, pin, value, self.outputvalue)
          return self.outputvalue
  
      def input(self, pin):
          assert self.iodir & (1 << pin) != 0, "Pin %s not set to input" % pin
          if self.num_gpios <= 8:
              value = self._device.readU8(INPUT_PORT)
          elif self.num_gpios > 8 and self.num_gpios <= 16:
              value = self._device.readU16(INPUT_PORT << 1)
          return value & (1 << pin)
  
      def setup(self, pin, mode):
          self.config(pin, mode)
  
      def cleanup(self, pin=None):
          # nothing to cleanup
          pass
  
subject: Add a GPIO class to support PCA9XXX chips