Programmazione su più back-end

Il mio attuale progetto è un pacchetto di astrazione di alto livello per la programmazione GPIO su quei simpatici piccoli computer SoC (Raspberry Pi, Cubieboard, Beaglebone Black, Pandaboard ecc.). Uno dei miei obiettivi è rendere possibile l'esecuzione dello stesso codice su schede diverse utilizzando come supporto moduli GPIO diversi, come RPi.GPIO sul Raspberry Pi o SUNXI_GPIO sulla Cubieboard.

Al momento ho un codice come questo:

class Pin(object):
    def __init__(self, gpio, direction, pud=None):
        self.gpio = gpio
        self.direction = direction
        self.pud = pud
        _GPIO_BACKEND.setuppin(self.gpio, self.direction, self.pud)

    def __str__(self):
        return self.gpio

class InputPin(Pin):
    """docstring for InputPin"""
    def read(self):
        _GPIO_BACKEND.read(self.gpio)

class OutputPin(Pin):
    """docstring for OutputPin"""
    def high(self):
        _GPIO_BACKEND.high(self.gpio)

    def low(self):
        _GPIO_BACKEND.low(self.gpio)

Mi piacerebbe _GPIO_BACKEND per ottenere l'installazione da un gestore di contesto che carica il back-end. Lo stesso Backend ha questo aspetto (esempio RPi.GPIO):

from RPi import GPIO as _GPIO

def init(numberscheme='bcm'):
    """docstring for init"""
    if numberscheme.lower() == 'bcm':
        _GPIO.setup(_GPIO.BCM)
    elif numberscheme.upper() == 'board':
        _GPIO.setup(_GPIO.BOARD)

def setuppin(id, direction, pullupdown=None):
    """docstring for setuppin"""
    if direction.lower() == 'in':
        dir = _GPIO.IN
    elif direction.lower() == 'out':
        dir = _GPIO.OUT
    else:
        raise ValueError

    if pullupdown is None:
        pud = _GPIO.PUD_ # TODO
    elif pullupdown.lower() == 'up':
        pud = _GPIO.PUD_UP
    elif pullupdown.lower() == 'down':
        pud = _GPIO.PUD_DOWN
    else:
        raise ValueError

    _GPIO.setmode(id, dir, pud)

def cleanup():
    """docstring for cleanup"""
    _GPIO.cleanup()

def high(id):
    """docstring for high"""
    _GPIO.output(id, _GPIO.HIGH)

def low(id):
    """docstring for low"""
    _GPIO.output(id, _GPIO.LOW)

def read(id):
    """docstring for read"""
    return _GPIO.input(id)

Ciò che non mi piace di questo è l'affidamento su una variabile globale pseudoinvisibile (_GPIO_BACKEND).

Quale è un modo buono, corretto e pitonioso di programmare su più backend come questo?