latest platformdetect api; clean up some pylint complaints & minor bugs

diff --git a/src/adafruit_blinka/__init__.py b/src/adafruit_blinka/__init__.py
index 845c802cb26731a0358ed474c60c2e4c5432f19c..47622df88c8bf50cd9059420c7c2b9215c276497 100755 (executable)
--- a/src/adafruit_blinka/__init__.py
+++ b/src/adafruit_blinka/__init__.py
@@ -5,7 +5,7 @@
 * Author(s): cefn
 """
 
 * Author(s): cefn
 """
 

-class Enum(object):
+class Enum():

     """
         Object supporting CircuitPython-style of static symbols
         as seen with Direction.OUTPUT, Pull.UP
     """
         Object supporting CircuitPython-style of static symbols
         as seen with Direction.OUTPUT, Pull.UP


@@ -43,9 +43,11 @@ class ContextManaged:
     def __exit__(self, exc_type, exc_value, traceback):
         self.deinit()
 
     def __exit__(self, exc_type, exc_value, traceback):
         self.deinit()
 

+    # pylint: disable=no-self-use

     def deinit(self):
         """Free any hardware used by the object."""
     def deinit(self):
         """Free any hardware used by the object."""

-        pass
+        return
+    # pylint: enable=no-self-use

 
 
 class Lockable(ContextManaged):
 
 
 class Lockable(ContextManaged):

diff --git a/src/adafruit_blinka/agnostic/__init__.py b/src/adafruit_blinka/agnostic/__init__.py
index cbd967c3804836f0ed2d0d0575f6453f17bb4469..1f6eb4c300537ea219a81014c254f32acddcf4fb 100755 (executable)
--- a/src/adafruit_blinka/agnostic/__init__.py
+++ b/src/adafruit_blinka/agnostic/__init__.py
@@ -10,13 +10,16 @@ import adafruit_platformdetect
 # We intentionally are patching into this namespace as module names so skip the name check.
 # pylint: disable=invalid-name
 
 # We intentionally are patching into this namespace as module names so skip the name check.
 # pylint: disable=invalid-name
 

-detect = adafruit_platformdetect.PlatformDetect()
+# We'll define board and chip id values in agnostic rather than accessing
+# detector directly elsewhere, just in case additional indirection is necessary
+# at some later point:

 
 

-board_name = detect.board.name()
-chip_name = detect.chip.name()
+detector = adafruit_platformdetect.Detector()
+chip_id = detector.chip.id
+board_id = detector.board.id

 
 implementation = sys.implementation.name
 if implementation == "micropython":
     from utime import sleep
 
 implementation = sys.implementation.name
 if implementation == "micropython":
     from utime import sleep

-elif implementation == "circuitpython" or implementation == "cpython":
+elif implementation in ("circuitpython", "cpython"):

     from time import sleep
     from time import sleep

diff --git a/src/bitbangio.py b/src/bitbangio.py
index 63265e3f7f81179a728b47a17fc8237393f3adc3..c4ffcfb10faa55cdac98d9c8307c00ca3661e431 100755 (executable)
--- a/src/bitbangio.py
+++ b/src/bitbangio.py
@@ -14,8 +14,8 @@ import adafruit_platformdetect.board as ap_board
 class I2C(Lockable):
     def __init__(self, scl, sda, frequency=400000):
         # TODO: This one is a bit questionable:
 class I2C(Lockable):
     def __init__(self, scl, sda, frequency=400000):
         # TODO: This one is a bit questionable:

-        if agnostic.board_name == ap_board.PYBOARD:
-            raise NotImplementedError("No software I2C on {}".format(agnostic.board_name))
+        if agnostic.board_id == ap_board.PYBOARD:
+            raise NotImplementedError("No software I2C on {}".format(agnostic.board_id))

         self.init(scl, sda, frequency)
 
     def init(self, scl, sda, frequency):
         self.init(scl, sda, frequency)
 
     def init(self, scl, sda, frequency):

diff --git a/src/board.py b/src/board.py
index b343c80b94b687ee7a97a15cde446a1a025e8228..566d86ae933278af3bb1e2c7f4d117db5c35081b 100755 (executable)
--- a/src/board.py
+++ b/src/board.py
@@ -29,25 +29,27 @@ See `CircuitPython:board` in CircuitPython for more details.
 """
 import sys
 
 """
 import sys
 

-from adafruit_blinka.agnostic import board_name
+from adafruit_blinka.agnostic import board_id

 import adafruit_platformdetect.board as ap_board
 
 import adafruit_platformdetect.board as ap_board
 

-if board_name == ap_board.FEATHER_HUZZAH:
+# pylint: disable=wildcard-import,unused-wildcard-import,ungrouped-imports
+
+if board_id == ap_board.FEATHER_HUZZAH:

     from adafruit_blinka.board.feather_huzzah import *
 
     from adafruit_blinka.board.feather_huzzah import *
 

-elif board_name == ap_board.NODEMCU:
+elif board_id == ap_board.NODEMCU:

     from adafruit_blinka.board.nodemcu import *
 
     from adafruit_blinka.board.nodemcu import *
 

-elif board_name == ap_board.PYBOARD:
+elif board_id == ap_board.PYBOARD:

     from adafruit_blinka.board.pyboard import *
 
     from adafruit_blinka.board.pyboard import *
 

-elif board_name in ap_board.ANY_RASPBERRY_PI_2_OR_3:
+elif board_id in ap_board.ANY_RASPBERRY_PI_2_OR_3:

     from adafruit_blinka.board.raspi_23 import *
 
     from adafruit_blinka.board.raspi_23 import *
 

-elif board_name == ap_board.BEAGLEBONE_BLACK:
+elif board_id == ap_board.BEAGLEBONE_BLACK:

     from adafruit_blinka.board.beaglebone_black import *
 
     from adafruit_blinka.board.beaglebone_black import *
 

-elif board_name == ap_board.ORANGEPI_PC:
+elif board_id == ap_board.ORANGEPI_PC:

     from adafruit_blinka.board.orangepipc import *
 
 elif "sphinx" in sys.modules:
     from adafruit_blinka.board.orangepipc import *
 
 elif "sphinx" in sys.modules:

diff --git a/src/busio.py b/src/busio.py
index 3c525beacb73d22ca37de43f7e1925ad4904bb72..d3bdbf55b9c1542271f3e63e2b6be281d3a58084 100755 (executable)
--- a/src/busio.py
+++ b/src/busio.py
@@ -8,7 +8,7 @@ See `CircuitPython:busio` in CircuitPython for more details.
 """
 
 from adafruit_blinka import Enum, Lockable, agnostic
 """
 
 from adafruit_blinka import Enum, Lockable, agnostic

-from adafruit_blinka.agnostic import board_name
+from adafruit_blinka.agnostic import board_id

 import adafruit_platformdetect.board as ap_board
 
 EMBEDDED_LINUX_BOARDS = (
 import adafruit_platformdetect.board as ap_board
 
 EMBEDDED_LINUX_BOARDS = (


@@ -25,7 +25,7 @@ class I2C(Lockable):
 
     def init(self, scl, sda, frequency):
         self.deinit()
 
     def init(self, scl, sda, frequency):
         self.deinit()

-        if board_name in EMBEDDED_LINUX_BOARDS:
+        if board_id in EMBEDDED_LINUX_BOARDS:

             from adafruit_blinka.microcontroller.generic_linux.i2c import I2C as _I2C
         else:
             from machine import I2C as _I2C
             from adafruit_blinka.microcontroller.generic_linux.i2c import I2C as _I2C
         else:
             from machine import I2C as _I2C


@@ -35,8 +35,9 @@ class I2C(Lockable):
                 self._i2c = _I2C(portId, mode=_I2C.MASTER, baudrate=frequency)
                 break
         else:
                 self._i2c = _I2C(portId, mode=_I2C.MASTER, baudrate=frequency)
                 break
         else:

-            raise NotImplementedError("No Hardware I2C on (scl,sda)={}\nValid UART ports".format(
-        (scl, sda), i2cPorts))
+            raise NotImplementedError(
+                "No Hardware I2C on (scl,sda)={}\nValid UART ports: {}".format((scl, sda), i2cPorts)
+            )

 
     def deinit(self):
         try:
 
     def deinit(self):
         try:


@@ -79,7 +80,7 @@ class I2C(Lockable):
 class SPI(Lockable):
     def __init__(self, clock, MOSI=None, MISO=None):
         self.deinit()
 class SPI(Lockable):
     def __init__(self, clock, MOSI=None, MISO=None):
         self.deinit()

-        if board_name in EMBEDDED_LINUX_BOARDS:
+        if board_id in EMBEDDED_LINUX_BOARDS:

             from adafruit_blinka.microcontroller.generic_linux.spi import SPI as _SPI
         else:
             from machine import SPI as _SPI
             from adafruit_blinka.microcontroller.generic_linux.spi import SPI as _SPI
         else:
             from machine import SPI as _SPI


@@ -97,13 +98,13 @@ class SPI(Lockable):
                 format((clock, MOSI, MISO), spiPorts))
 
     def configure(self, baudrate=100000, polarity=0, phase=0, bits=8):
                 format((clock, MOSI, MISO), spiPorts))
 
     def configure(self, baudrate=100000, polarity=0, phase=0, bits=8):

-        if board_name in ap_board.ANY_RASPBERRY_PI_2_OR_3:
+        if board_id in ap_board.ANY_RASPBERRY_PI_2_OR_3:

             from adafruit_blinka.microcontroller.bcm283x.pin import Pin
             from adafruit_blinka.microcontroller.generic_linux.spi import SPI as _SPI
             from adafruit_blinka.microcontroller.bcm283x.pin import Pin
             from adafruit_blinka.microcontroller.generic_linux.spi import SPI as _SPI

-        elif board_name == ap_board.BEAGLEBONE_BLACK:
+        elif board_id == ap_board.BEAGLEBONE_BLACK:

             from adafruit_blinka.microcontroller.am335x.pin import Pin
             from adafruit_blinka.microcontroller.generic_linux.spi import SPI as _SPI
             from adafruit_blinka.microcontroller.am335x.pin import Pin
             from adafruit_blinka.microcontroller.generic_linux.spi import SPI as _SPI

-        elif board_name == ap_board.ORANGEPI_PC:
+        elif board_id == ap_board.ORANGEPI_PC:

             from adafruit_blinka.microcontroller.allwinner_h3.pin import Pin
             from adafruit_blinka.microcontroller.generic_linux.spi import SPI as _SPI
         else:
             from adafruit_blinka.microcontroller.allwinner_h3.pin import Pin
             from adafruit_blinka.microcontroller.generic_linux.spi import SPI as _SPI
         else:


@@ -164,7 +165,7 @@ class UART(Lockable):
         if flow is not None:  # default 0
             raise NotImplementedError(
                 "Parameter '{}' unsupported on {}".format(
         if flow is not None:  # default 0
             raise NotImplementedError(
                 "Parameter '{}' unsupported on {}".format(

-                    "flow", agnostic.board))
+                    "flow", agnostic.board_id))

 
         # translate parity flag for Micropython
         if parity is UART.Parity.ODD:
 
         # translate parity flag for Micropython
         if parity is UART.Parity.ODD:


@@ -191,8 +192,8 @@ class UART(Lockable):
                 break
         else:
             raise NotImplementedError(
                 break
         else:
             raise NotImplementedError(

-                "No Hardware UART on (tx,rx)={}\nValid UART ports".format(
-                    (tx, rx), uartPorts))
+                "No Hardware UART on (tx,rx)={}\nValid UART ports: {}".format((tx, rx), uartPorts)
+            )

 
     def deinit(self):
         self._uart = None
 
     def deinit(self):
         self._uart = None

diff --git a/src/digitalio.py b/src/digitalio.py
index 631a7718b6b7f26882987b34ce0bee2fb9d3391e..ee1fd214da3b9c1f74e13815c54d1c0c8d3b27e3 100755 (executable)
--- a/src/digitalio.py
+++ b/src/digitalio.py
@@ -7,14 +7,17 @@ See `CircuitPython:digitalio` in CircuitPython for more details.
 * Author(s): cefn
 """
 
 * Author(s): cefn
 """
 

-from adafruit_blinka.agnostic import board_id
-if board_id == "raspi_3" or board_id == "raspi_2":
+from adafruit_blinka.agnostic import board_id, detector
+
+# pylint: disable=ungrouped-imports,wrong-import-position
+
+if detector.board.any_raspberry_pi_2_or_3:

     from adafruit_blinka.microcontroller.bcm283x.pin import Pin
     from adafruit_blinka.microcontroller.bcm283x.pin import Pin

-elif board_id == "beaglebone_black":
+elif detector.board.BEAGLEBONE_BLACK:

     from adafruit_blinka.microcontroller.am335x.pin import Pin
     from adafruit_blinka.microcontroller.am335x.pin import Pin

-elif board_id == "orangepipc":
+elif detector.board.ORANGE_PI_PC:

     from adafruit_blinka.microcontroller.allwinner_h3.pin import Pin
     from adafruit_blinka.microcontroller.allwinner_h3.pin import Pin

-elif board_id == "pyboard":
+elif detector.board.PYBOARD:

     from machine import Pin
 from adafruit_blinka import Enum, ContextManaged
 
     from machine import Pin
 from adafruit_blinka import Enum, ContextManaged
 


@@ -113,7 +116,7 @@ class DigitalInOut(ContextManaged):
                     self._pin.init(mode=Pin.IN, pull=Pin.PULL_DOWN)
                 else:
                     raise NotImplementedError("{} unsupported on {}".format(
                     self._pin.init(mode=Pin.IN, pull=Pin.PULL_DOWN)
                 else:
                     raise NotImplementedError("{} unsupported on {}".format(

-                        Pull.DOWN, boardId))
+                        Pull.DOWN, board_id))

             elif pul is None:
                 self._pin.init(mode=Pin.IN, pull=None)
             else:
             elif pul is None:
                 self._pin.init(mode=Pin.IN, pull=None)
             else:

diff --git a/src/microcontroller/__init__.py b/src/microcontroller/__init__.py
index 0cbdfda0e92f4c7bb34876d879fb2494b037c436..54fd6c88e7067ee01e399bc39549a8b5981b3e49 100755 (executable)
--- a/src/microcontroller/__init__.py
+++ b/src/microcontroller/__init__.py
@@ -1,7 +1,8 @@
 """Microcontroller pins"""
 
 from adafruit_blinka import Enum
 """Microcontroller pins"""
 
 from adafruit_blinka import Enum

-from adafruit_blinka.agnostic import board_id, platform
+from adafruit_blinka.agnostic import board_id, chip_id
+from adafruit_platformdetect import chip as ap_chip

 
 class Pin(Enum):
     """Reference Pin object"""
 
 class Pin(Enum):
     """Reference Pin object"""


@@ -21,20 +22,17 @@ class Pin(Enum):
         return repr(self)
 
 # We intentionally are patching into this namespace so skip the wildcard check.
         return repr(self)
 
 # We intentionally are patching into this namespace so skip the wildcard check.

-# pylint: disable=unused-wildcard-import,wildcard-import
+# pylint: disable=unused-wildcard-import,wildcard-import,ungrouped-imports

 
 

-if platform == "esp8266":
+if chip_id == ap_chip.ESP8266:

     from adafruit_blinka.microcontroller.esp8266 import *
     from adafruit_blinka.microcontroller.esp8266 import *

-elif platform == "stm32":
+elif chip_id == ap_chip.STM32:

     from adafruit_blinka.microcontroller.stm32 import *
     from adafruit_blinka.microcontroller.stm32 import *

-elif platform == "linux":
-    if board_id == "raspi_3" or board_id == "raspi_2":
-        from adafruit_blinka.microcontroller.bcm283x import *
-    elif board_id == "beaglebone_black":
-        from adafruit_blinka.microcontroller.am335x import *
-    elif board_id == "orangepipc":
-        from adafruit_blinka.microcontroller.allwinner_h3 import *
-    else:
-        raise NotImplementedError("Board not supported:", board_id)
+elif chip_id == ap_chip.BCM2XXX:
+    from adafruit_blinka.microcontroller.bcm283x import *
+elif chip_id == ap_chip.AM33XX:
+    from adafruit_blinka.microcontroller.am335x import *
+elif chip_id == ap_chip.SUN8I:
+    from adafruit_blinka.microcontroller.allwinner_h3 import *

 else:
 else:

-    raise NotImplementedError("Platform not supported:", platform)
+    raise NotImplementedError("Microcontroller not supported:", chip_id)

diff --git a/src/microcontroller/pin.py b/src/microcontroller/pin.py
index b3dd4cae80bdce3814ece64be0bd8d39d27f3131..5908d438e81a3d171513df162b17ce16717e2d9d 100755 (executable)
--- a/src/microcontroller/pin.py
+++ b/src/microcontroller/pin.py
@@ -1,19 +1,20 @@
 """Pins named after their chip name."""
 
 """Pins named after their chip name."""
 

-from adafruit_blinka import agnostic
+from adafruit_blinka.agnostic import chip_id

 import adafruit_platformdetect.chip as ap_chip
 
 # We intentionally are patching into this namespace so skip the wildcard check.
 import adafruit_platformdetect.chip as ap_chip
 
 # We intentionally are patching into this namespace so skip the wildcard check.

-# pylint: disable=unused-wildcard-import,wildcard-import
-if agnostic.chip_name == ap_chip.ESP8266:
+# pylint: disable=unused-wildcard-import,wildcard-import,ungrouped-imports
+
+if chip_id == ap_chip.ESP8266:

     from adafruit_blinka.microcontroller.esp8266.pin import *
     from adafruit_blinka.microcontroller.esp8266.pin import *

-elif agnostic.chip_name == ap_chip.STM32:
+elif chip_id == ap_chip.STM32:

     from adafruit_blinka.microcontroller.stm32.pin import *
     from adafruit_blinka.microcontroller.stm32.pin import *

-elif agnostic.detect.any_raspberry_pi_or_3:
+elif chip_id == ap_chip.BCM2XXX:

     from adafruit_blinka.microcontroller.bcm283x.pin import *
     from adafruit_blinka.microcontroller.bcm283x.pin import *

-elif agnostic.detect.beaglebone_black:
+elif chip_id == ap_chip.AM33XX:

     from adafruit_blinka.microcontroller.am335x.pin import *
     from adafruit_blinka.microcontroller.am335x.pin import *

-elif agnostic.detect.orangepi_pc:
+elif chip_id == ap_chip.SUN8I:

     from adafruit_blinka.microcontroller.allwinner_h3.pin import *
 else:
     from adafruit_blinka.microcontroller.allwinner_h3.pin import *
 else:

-    raise NotImplementedError("Board / microcontroller not supported: ", agnostic.board_name)
+    raise NotImplementedError("Microcontroller not supported: ", chip_id)

diff --git a/src/neopixel_write.py b/src/neopixel_write.py
index cee24cf0b6be1af4f117806b253b565151850de5..5626bc632bace3df0884ecfad19edc8c210310f5 100644 (file)
--- a/src/neopixel_write.py
+++ b/src/neopixel_write.py
@@ -9,10 +9,9 @@ See `CircuitPython:neopixel_write` in CircuitPython for more details.
 
 import sys
 
 
 import sys
 

-from adafruit_blinka.agnostic import board_name
-import adafruit_platformdetect.board as ap_board
+from adafruit_blinka.agnostic import detector

 
 

-if board_name in (ap_board.RASPBERRY_PI_2B, ap_board.RASPBERRY_PI_3B, ap_board.RASPBERRY_PI_B_PLUS):
+if detector.board.any_raspberry_pi:

     from adafruit_blinka.microcontroller.bcm283x import neopixel as _neopixel
 elif "sphinx" in sys.modules:
     pass
     from adafruit_blinka.microcontroller.bcm283x import neopixel as _neopixel
 elif "sphinx" in sys.modules:
     pass

diff --git a/src/pulseio.py b/src/pulseio.py
index cba0941bd1b185d681e855927df88965a0e4b07d..9bee175fd3835c538d7c71aa7005b1a6ad105bcc 100644 (file)
--- a/src/pulseio.py
+++ b/src/pulseio.py
@@ -1,6 +1,4 @@
-import sys
-from adafruit_blinka.agnostic import board_id
+from adafruit_blinka.agnostic import detector

 
 

-
-if board_id == "raspi_2" or board_id == "raspi_3":
-    from adafruit_blinka.microcontroller.bcm283x.pulseio.PulseIn import PulseIn as PulseIn
+if detector.board.any_raspberry_pi_2_or_3:
+    from adafruit_blinka.microcontroller.bcm283x.pulseio.PulseIn import PulseIn