# This example finds and connects to a peripheral running the
# UART service (e.g. ble_simple_peripheral.py).

import bluetooth
import random
import struct
import time
import micropython


            

Reported by Pylint.

              import random
import struct
import time
import micropython

from ble_advertising import decode_services, decode_name

from micropython import const


            

Reported by Pylint.

              
from ble_advertising import decode_services, decode_name

from micropython import const

_IRQ_CENTRAL_CONNECT = const(1)
_IRQ_CENTRAL_DISCONNECT = const(2)
_IRQ_GATTS_WRITE = const(3)
_IRQ_GATTS_READ_REQUEST = const(4)

            

Reported by Pylint.

              
    # Wait for connection...
    while not central.is_connected():
        time.sleep_ms(100)
        if not_found:
            return

    print("Connected")


            

Reported by Pylint.

                      except:
            print("TX failed")
        i += 1
        time.sleep_ms(400 if with_response else 30)

    print("Disconnected")


if __name__ == "__main__":

            

Reported by Pylint.

              # UART service (e.g. ble_simple_peripheral.py).

import bluetooth
import random
import struct
import time
import micropython

from ble_advertising import decode_services, decode_name

            

Reported by Pylint.

              
import bluetooth
import random
import struct
import time
import micropython

from ble_advertising import decode_services, decode_name


            

Reported by Pylint.

              import random
import struct
import time
import micropython

from ble_advertising import decode_services, decode_name

from micropython import const


            

Reported by Pylint.

              
    def _irq(self, event, data):
        if event == _IRQ_SCAN_RESULT:
            addr_type, addr, adv_type, rssi, adv_data = data
            if adv_type in (_ADV_IND, _ADV_DIRECT_IND) and _UART_SERVICE_UUID in decode_services(
                adv_data
            ):
                # Found a potential device, remember it and stop scanning.
                self._addr_type = addr_type

            

Reported by Pylint.

                              adv_data
            ):
                # Found a potential device, remember it and stop scanning.
                self._addr_type = addr_type
                self._addr = bytes(
                    addr
                )  # Note: addr buffer is owned by caller so need to copy it.
                self._name = decode_name(adv_data) or "?"
                self._ble.gap_scan(None)

            

Reported by Pylint.

                              break

    def solveNSteps(self, nSteps):
        for i in range(nSteps):
            if not self.iterate():
                break

    def series(self):
        return zip(*self.Trajectory)

            

Reported by Pylint.

                      r += step


def phaseDiagram(system, trajStart, trajPlot, h=0.1, tend=1.0, range=1.0):
    tstart = 0.0
    for i in drange(0, range, 0.1 * range):
        for j in drange(0, range, 0.1 * range):
            rk = RungeKutta(system, trajStart(i, j), tstart, h)
            rk.solve(tend)

            

Reported by Pylint.

                          print()
            # draw the arrow
            continue
            l = (len(rk.Trajectory) - 1) / 3
            if l > 0 and 2 * l < len(rk.Trajectory):
                p1 = rk.Trajectory[l]
                p2 = rk.Trajectory[2 * l]
                x1, y1 = trajPlot(p1)
                x2, y2 = trajPlot(p2)

            

Reported by Pylint.

              # evolve the RGEs of the standard model from electroweak scale up
# by dpgeorge

import math


class RungeKutta(object):
    def __init__(self, functions, initConditions, t0, dh, save=True):
        self.Trajectory, self.save = [[t0] + initConditions], save

            

Reported by Pylint.

              import math


class RungeKutta(object):
    def __init__(self, functions, initConditions, t0, dh, save=True):
        self.Trajectory, self.save = [[t0] + initConditions], save
        self.functions = [lambda *args: 1.0] + list(functions)
        self.N, self.dh = len(self.functions), dh
        self.coeff = [1.0 / 6.0, 2.0 / 6.0, 2.0 / 6.0, 1.0 / 6.0]

            

Reported by Pylint.

              import math


class RungeKutta(object):
    def __init__(self, functions, initConditions, t0, dh, save=True):
        self.Trajectory, self.save = [[t0] + initConditions], save
        self.functions = [lambda *args: 1.0] + list(functions)
        self.N, self.dh = len(self.functions), dh
        self.coeff = [1.0 / 6.0, 2.0 / 6.0, 2.0 / 6.0, 1.0 / 6.0]

            

Reported by Pylint.

              

class RungeKutta(object):
    def __init__(self, functions, initConditions, t0, dh, save=True):
        self.Trajectory, self.save = [[t0] + initConditions], save
        self.functions = [lambda *args: 1.0] + list(functions)
        self.N, self.dh = len(self.functions), dh
        self.coeff = [1.0 / 6.0, 2.0 / 6.0, 2.0 / 6.0, 1.0 / 6.0]
        self.InArgCoeff = [0.0, 0.5, 0.5, 1.0]

            

Reported by Pylint.

              
class RungeKutta(object):
    def __init__(self, functions, initConditions, t0, dh, save=True):
        self.Trajectory, self.save = [[t0] + initConditions], save
        self.functions = [lambda *args: 1.0] + list(functions)
        self.N, self.dh = len(self.functions), dh
        self.coeff = [1.0 / 6.0, 2.0 / 6.0, 2.0 / 6.0, 1.0 / 6.0]
        self.InArgCoeff = [0.0, 0.5, 0.5, 1.0]


            

Reported by Pylint.

                  def __init__(self, functions, initConditions, t0, dh, save=True):
        self.Trajectory, self.save = [[t0] + initConditions], save
        self.functions = [lambda *args: 1.0] + list(functions)
        self.N, self.dh = len(self.functions), dh
        self.coeff = [1.0 / 6.0, 2.0 / 6.0, 2.0 / 6.0, 1.0 / 6.0]
        self.InArgCoeff = [0.0, 0.5, 0.5, 1.0]

    def iterate(self):
        step = self.Trajectory[-1][:]

            

Reported by Pylint.

                  def __init__(self, functions, initConditions, t0, dh, save=True):
        self.Trajectory, self.save = [[t0] + initConditions], save
        self.functions = [lambda *args: 1.0] + list(functions)
        self.N, self.dh = len(self.functions), dh
        self.coeff = [1.0 / 6.0, 2.0 / 6.0, 2.0 / 6.0, 1.0 / 6.0]
        self.InArgCoeff = [0.0, 0.5, 0.5, 1.0]

    def iterate(self):
        step = self.Trajectory[-1][:]

            

Reported by Pylint.

              # Driver test for official MicroPython LCD160CR display
# MIT license; Copyright (c) 2017 Damien P. George

import time, math, framebuf, lcd160cr


def get_lcd(lcd):
    if type(lcd) is str:
        lcd = lcd160cr.LCD160CR(lcd)

            

Reported by Pylint.

              def test_features(lcd, orient=lcd160cr.PORTRAIT):
    # if we run on pyboard then use ADC and RTC features
    try:
        import pyb

        adc = pyb.ADCAll(12, 0xF0000)
        rtc = pyb.RTC()
    except:
        adc = None

            

Reported by Pylint.

              
    # initialise loop parameters
    tx = ty = 0
    t0 = time.ticks_us()

    for i in range(300):
        # update position of cross-hair
        t, tx2, ty2 = lcd.get_touch()
        if t:

            

Reported by Pylint.

                          )

        # compute the frame rate
        t1 = time.ticks_us()
        dt = time.ticks_diff(t1, t0)
        t0 = t1

        # show the frame rate
        lcd.set_pos(2, 9)

            

Reported by Pylint.

              
        # compute the frame rate
        t1 = time.ticks_us()
        dt = time.ticks_diff(t1, t0)
        t0 = t1

        # show the frame rate
        lcd.set_pos(2, 9)
        lcd.write("%.2f fps" % (1000000 / dt))

            

Reported by Pylint.

                  data = [adc.read_core_temp(), adc.read_core_vbat(), 3.3]
    try:
        data[2] = adc.read_vref()
    except:
        pass
    for i in range(3):
        lcd.set_text_color((825, 1625, 1600)[i], 0)
        if lcd.h == 160:
            lcd.set_font(2)

            

Reported by Pylint.

              
        adc = pyb.ADCAll(12, 0xF0000)
        rtc = pyb.RTC()
    except:
        adc = None
        rtc = None

    # set orientation and clear screen
    lcd = get_lcd(lcd)

            

Reported by Pylint.

              # Driver test for official MicroPython LCD160CR display
# MIT license; Copyright (c) 2017 Damien P. George

import time, math, framebuf, lcd160cr


def get_lcd(lcd):
    if type(lcd) is str:
        lcd = lcd160cr.LCD160CR(lcd)

            

Reported by Pylint.

              # Driver test for official MicroPython LCD160CR display
# MIT license; Copyright (c) 2017 Damien P. George

import time, math, framebuf, lcd160cr


def get_lcd(lcd):
    if type(lcd) is str:
        lcd = lcd160cr.LCD160CR(lcd)

            

Reported by Pylint.

              # Driver test for official MicroPython LCD160CR display
# MIT license; Copyright (c) 2017 Damien P. George

import time, math, framebuf, lcd160cr


def get_lcd(lcd):
    if type(lcd) is str:
        lcd = lcd160cr.LCD160CR(lcd)

            

Reported by Pylint.

              #   - using the second core via _thread

import _thread
from machine import Pin, UART
from rp2 import PIO, StateMachine, asm_pio

UART_BAUD = 9600

HARD_UART_TX_PIN = Pin(4, Pin.OUT)

            

Reported by Pylint.

              
import _thread
from machine import Pin, UART
from rp2 import PIO, StateMachine, asm_pio

UART_BAUD = 9600

HARD_UART_TX_PIN = Pin(4, Pin.OUT)
PIO_RX_PIN = Pin(3, Pin.IN, Pin.PULL_UP)

            

Reported by Pylint.

              @asm_pio(
    autopush=True,
    push_thresh=8,
    in_shiftdir=rp2.PIO.SHIFT_RIGHT,
    fifo_join=PIO.JOIN_RX,
)
def uart_rx_mini():
    # fmt: off
    # Wait for start bit

            

Reported by Pylint.

              def uart_rx_mini():
    # fmt: off
    # Wait for start bit
    wait(0, pin, 0)
    # Preload bit counter, delay until eye of first data bit
    set(x, 7)                 [10]
    # Loop 8 times
    label("bitloop")
    # Sample data

            

Reported by Pylint.

              def uart_rx_mini():
    # fmt: off
    # Wait for start bit
    wait(0, pin, 0)
    # Preload bit counter, delay until eye of first data bit
    set(x, 7)                 [10]
    # Loop 8 times
    label("bitloop")
    # Sample data

            

Reported by Pylint.

                  # Wait for start bit
    wait(0, pin, 0)
    # Preload bit counter, delay until eye of first data bit
    set(x, 7)                 [10]
    # Loop 8 times
    label("bitloop")
    # Sample data
    in_(pins, 1)
    # Each iteration is 8 cycles

            

Reported by Pylint.

                  # Wait for start bit
    wait(0, pin, 0)
    # Preload bit counter, delay until eye of first data bit
    set(x, 7)                 [10]
    # Loop 8 times
    label("bitloop")
    # Sample data
    in_(pins, 1)
    # Each iteration is 8 cycles

            

Reported by Pylint.

                  # Preload bit counter, delay until eye of first data bit
    set(x, 7)                 [10]
    # Loop 8 times
    label("bitloop")
    # Sample data
    in_(pins, 1)
    # Each iteration is 8 cycles
    jmp(x_dec, "bitloop")     [6]
    # fmt: on

            

Reported by Pylint.

                  # Loop 8 times
    label("bitloop")
    # Sample data
    in_(pins, 1)
    # Each iteration is 8 cycles
    jmp(x_dec, "bitloop")     [6]
    # fmt: on



            

Reported by Pylint.

                  # Loop 8 times
    label("bitloop")
    # Sample data
    in_(pins, 1)
    # Each iteration is 8 cycles
    jmp(x_dec, "bitloop")     [6]
    # fmt: on



            

Reported by Pylint.

                      return "pin_{:s}_af".format(self.cpu_pin_name())

    def adc_num_str(self):
        str = ""
        for adc_num in range(1, 4):
            if self.adc_num & (1 << (adc_num - 1)):
                if len(str) > 0:
                    str += " | "
                str += "PIN_ADC"

            

Reported by Pylint.

                          for row in rows:
                try:
                    pin_num = parse_pin(row[pinname_col])
                except:
                    continue
                pin = Pin(pin_num)
                for af_idx in range(af_col, len(row)):
                    if af_idx < af_col_end:
                        pin.parse_af(af_idx - af_col, row[af_idx])

            

Reported by Pylint.

                          for row in rows:
                try:
                    pin_num = parse_pin(row[1])
                except:
                    continue
                pin = self.find_pin(pin_num)
                if pin:
                    pin.set_is_board_pin()
                    self.board_pins.append(NamedPin(row[0], pin))

            

Reported by Pylint.

                              )
        print("};")
        print(
            "MP_DEFINE_CONST_DICT(pin_{:s}_pins_locals_dict, pin_{:s}_pins_locals_dict_table);".format(
                label, label
            )
        )

    def print_const_table(self):

            

Reported by Pylint.

              #!/usr/bin/env python
"""Creates the pin file for the nRF5."""

from __future__ import print_function

import argparse
import sys
import csv


            

Reported by Pylint.

                  return int(pin_str)


def split_name_num(name_num):
    num = None
    for num_idx in range(len(name_num) - 1, -1, -1):
        if not name_num[num_idx].isdigit():
            name = name_num[0 : num_idx + 1]
            num_str = name_num[num_idx + 1 :]

            

Reported by Pylint.

                  return name, num


class AlternateFunction(object):
    """Holds the information associated with a pins alternate function."""

    def __init__(self, idx, af_str):
        self.idx = idx
        self.af_str = af_str

            

Reported by Pylint.

                          if self.pin_type in pin_types:
                self.supported = True

    def is_supported(self):
        return self.supported

    def ptr(self):
        """Returns the numbered function (i.e. USART6) for this AF."""
        if self.fn_num is None:

            

Reported by Pylint.

                          return self.func
        return "{:s}{:d}".format(self.func, self.fn_num)

    def mux_name(self):
        return "AF{:d}_{:s}".format(self.idx, self.ptr())

    def print(self):
        """Prints the C representation of this AF."""
        if self.supported:

            

Reported by Pylint.

                          )
        )

    def qstr_list(self):
        return [self.mux_name()]


class Pin(object):
    """Holds the information associated with a pin."""

            

Reported by Pylint.

              # This example finds and connects to a BLE temperature sensor (e.g. the one in ble_temperature.py).

import bluetooth
import random
import struct
import time
import micropython

from ble_advertising import decode_services, decode_name

            

Reported by Pylint.

              import random
import struct
import time
import micropython

from ble_advertising import decode_services, decode_name

from micropython import const


            

Reported by Pylint.

              
from ble_advertising import decode_services, decode_name

from micropython import const

_IRQ_CENTRAL_CONNECT = const(1)
_IRQ_CENTRAL_DISCONNECT = const(2)
_IRQ_GATTS_WRITE = const(3)
_IRQ_GATTS_READ_REQUEST = const(4)

            

Reported by Pylint.

              
    # Wait for connection...
    while not central.is_connected():
        time.sleep_ms(100)
        if not_found:
            return

    print("Connected")


            

Reported by Pylint.

                  # Explicitly issue reads, using "print" as the callback.
    while central.is_connected():
        central.read(callback=print)
        time.sleep_ms(2000)

    # Alternative to the above, just show the most recently notified value.
    # while central.is_connected():
    #     print(central.value())
    #     time.sleep_ms(2000)

            

Reported by Pylint.

              # This example finds and connects to a BLE temperature sensor (e.g. the one in ble_temperature.py).

import bluetooth
import random
import struct
import time
import micropython

from ble_advertising import decode_services, decode_name

            

Reported by Pylint.

              import random
import struct
import time
import micropython

from ble_advertising import decode_services, decode_name

from micropython import const


            

Reported by Pylint.

              
    def _irq(self, event, data):
        if event == _IRQ_SCAN_RESULT:
            addr_type, addr, adv_type, rssi, adv_data = data
            if adv_type in (_ADV_IND, _ADV_DIRECT_IND) and _ENV_SENSE_UUID in decode_services(
                adv_data
            ):
                # Found a potential device, remember it and stop scanning.
                self._addr_type = addr_type

            

Reported by Pylint.

                              adv_data
            ):
                # Found a potential device, remember it and stop scanning.
                self._addr_type = addr_type
                self._addr = bytes(
                    addr
                )  # Note: addr buffer is owned by caller so need to copy it.
                self._name = decode_name(adv_data) or "?"
                self._ble.gap_scan(None)

            

Reported by Pylint.

                          ):
                # Found a potential device, remember it and stop scanning.
                self._addr_type = addr_type
                self._addr = bytes(
                    addr
                )  # Note: addr buffer is owned by caller so need to copy it.
                self._name = decode_name(adv_data) or "?"
                self._ble.gap_scan(None)


            

Reported by Pylint.

              #     p = PowerUp3()

import time
from machine import ADC
from machine import Pin
from ubluepy import Peripheral, Scanner, constants


def bytes_to_str(bytes):

            

Reported by Pylint.

              
import time
from machine import ADC
from machine import Pin
from ubluepy import Peripheral, Scanner, constants


def bytes_to_str(bytes):
    string = ""

            

Reported by Pylint.

              import time
from machine import ADC
from machine import Pin
from ubluepy import Peripheral, Scanner, constants


def bytes_to_str(bytes):
    string = ""
    for b in bytes:

            

Reported by Pylint.

              
        while True:

            time.sleep_ms(100)

            # read out new angle
            new_angle = self.read_stick_x()
            if new_angle < 256:
                if new_angle > right_threshold:

            

Reported by Pylint.

              from ubluepy import Peripheral, Scanner, constants


def bytes_to_str(bytes):
    string = ""
    for b in bytes:
        string += chr(b)
    return string


            

Reported by Pylint.

                      service_batt = s[3]
        service_control = s[4]

        self.char_batt_lvl = service_batt.getCharacteristics()[0]
        self.char_control_speed = service_control.getCharacteristics()[0]
        self.char_control_angle = service_control.getCharacteristics()[2]

    def battery_level(self):
        return int(self.char_batt_lvl.read()[0])

            

Reported by Pylint.

                      service_control = s[4]

        self.char_batt_lvl = service_batt.getCharacteristics()[0]
        self.char_control_speed = service_control.getCharacteristics()[0]
        self.char_control_angle = service_control.getCharacteristics()[2]

    def battery_level(self):
        return int(self.char_batt_lvl.read()[0])


            

Reported by Pylint.

              
        self.char_batt_lvl = service_batt.getCharacteristics()[0]
        self.char_control_speed = service_control.getCharacteristics()[0]
        self.char_control_angle = service_control.getCharacteristics()[2]

    def battery_level(self):
        return int(self.char_batt_lvl.read()[0])

    def speed(self, new_speed=None):

            

Reported by Pylint.

              
    def rudder_center(self):
        if self.old_angle != 0:
            self.old_angle = 0
            self.angle(0)

    def rudder_left(self, angle):
        steps = angle // self.interval_size_left
        new_angle = 60 - steps

            

Reported by Pylint.

              
        if self.old_angle != new_angle:
            self.angle(new_angle)
            self.old_angle = new_angle

    def rudder_right(self, angle):
        steps = angle // self.interval_size_right
        new_angle = -steps


            

Reported by Pylint.

              import os, sys
import serial.tools.list_ports

from . import pyboardextended as pyboard
from .console import Console, ConsolePosix

_PROG = "mpremote"

_BUILTIN_COMMAND_EXPANSIONS = {

            

Reported by Pylint.

              import serial.tools.list_ports

from . import pyboardextended as pyboard
from .console import Console, ConsolePosix

_PROG = "mpremote"

_BUILTIN_COMMAND_EXPANSIONS = {
    # Device connection shortcuts.

            

Reported by Pylint.

              import serial.tools.list_ports

from . import pyboardextended as pyboard
from .console import Console, ConsolePosix

_PROG = "mpremote"

_BUILTIN_COMMAND_EXPANSIONS = {
    # Device connection shortcuts.

            

Reported by Pylint.

                      config_data = f.read()
    prev_cwd = os.getcwd()
    os.chdir(path)
    exec(config_data, config.__dict__)
    os.chdir(prev_cwd)

    return config



            

Reported by Bandit.

                      config_data = f.read()
    prev_cwd = os.getcwd()
    os.chdir(path)
    exec(config_data, config.__dict__)
    os.chdir(prev_cwd)

    return config



            

Reported by Pylint.

              

def prepare_command_expansions(config):
    global _command_expansions

    _command_expansions = {}

    for command_set in (_BUILTIN_COMMAND_EXPANSIONS, config.commands):
        for cmd, sub in command_set.items():

            

Reported by Pylint.

                          _list_recursive(src_files, path)
        known_dirs = {""}
        pyb.exec_("import uos")
        for dir, file in src_files:
            dir_parts = dir.split("/")
            for i in range(len(dir_parts)):
                d = "/".join(dir_parts[: i + 1])
                if d not in known_dirs:
                    pyb.exec_("try:\n uos.mkdir('%s')\nexcept OSError as e:\n print(e)" % d)

            

Reported by Pylint.

                  try:
        pyb.exec_raw_no_follow(buf)
        if follow:
            ret, ret_err = pyb.follow(timeout=None, data_consumer=pyboard.stdout_write_bytes)
            if ret_err:
                pyboard.stdout_write_bytes(ret_err)
                ret_val = 1
    except pyboard.PyboardError as er:
        print(er)

            

Reported by Pylint.

                  mpremote repl                    -- enter REPL
"""

import os, sys
import serial.tools.list_ports

from . import pyboardextended as pyboard
from .console import Console, ConsolePosix


            

Reported by Pylint.

                  "rmdir": "fs rmdir",
    "df": [
        "exec",
        "import uos\nprint('mount \\tsize \\tused \\tavail \\tuse%')\nfor _m in [''] + uos.listdir('/'):\n _s = uos.stat('/' + _m)\n if not _s[0] & 1 << 14: continue\n _s = uos.statvfs(_m)\n if _s[0]:\n  _size = _s[0] * _s[2]; _free = _s[0] * _s[3]; print(_m, _size, _size - _free, _free, int(100 * (_size - _free) / _size), sep='\\t')",
    ],
    # Other shortcuts.
    "reset t_ms=100": [
        "exec",
        "--no-follow",

            

Reported by Pylint.

                      return "pin_{:s}_af".format(self.cpu_pin_name())

    def adc_num_str(self):
        str = ""
        for adc_num in range(1, 4):
            if self.adc_num & (1 << (adc_num - 1)):
                if len(str) > 0:
                    str += " | "
                str += "PIN_ADC"

            

Reported by Pylint.

                          for row in rows:
                try:
                    (port_num, pin_num) = parse_port_pin(row[pinname_col])
                except:
                    continue
                pin = Pin(port_num, pin_num)
                for af_idx in range(af_col, len(row)):
                    if af_idx >= af_col:
                        pin.parse_af(af_idx - af_col, row[af_idx])

            

Reported by Pylint.

                          for row in rows:
                try:
                    (port_num, pin_num) = parse_port_pin(row[1])
                except:
                    continue
                pin = self.find_pin(port_num, pin_num)
                if pin:
                    pin.set_is_board_pin()
                    self.board_pins.append(NamedPin(row[0], pin))

            

Reported by Pylint.

                              )
        print("};")
        print(
            "MP_DEFINE_CONST_DICT(pin_{:s}_pins_locals_dict, pin_{:s}_pins_locals_dict_table);".format(
                label, label
            )
        )

    def print(self):

            

Reported by Pylint.

              #!/usr/bin/env python
"""Creates the pin file for the Teensy."""

from __future__ import print_function

import argparse
import sys
import csv


            

Reported by Pylint.

                  return (port, int(pin_str))


def split_name_num(name_num):
    num = None
    for num_idx in range(len(name_num) - 1, -1, -1):
        if not name_num[num_idx].isdigit():
            name = name_num[0 : num_idx + 1]
            num_str = name_num[num_idx + 1 :]

            

Reported by Pylint.

                  return name, num


class AlternateFunction(object):
    """Holds the information associated with a pins alternate function."""

    def __init__(self, idx, af_str):
        self.idx = idx
        self.af_str = af_str

            

Reported by Pylint.

                          if self.pin_type in pin_types:
                self.supported = True

    def is_supported(self):
        return self.supported

    def ptr(self):
        """Returns the numbered function (i.e. USART6) for this AF."""
        if self.fn_num is None:

            

Reported by Pylint.

                          return self.func
        return "{:s}{:d}".format(self.func, self.fn_num)

    def mux_name(self):
        return "AF{:d}_{:s}".format(self.idx, self.ptr())

    def print(self):
        """Prints the C representation of this AF."""
        if self.supported:

            

Reported by Pylint.

                          )
        )

    def qstr_list(self):
        return [self.mux_name()]


class Pin(object):
    """Holds the information associated with a pin."""

            

Reported by Pylint.

                          raise Exception("no I2C mboot device found")

    def wait_response(self):
        start = time.ticks_ms()
        while 1:
            try:
                self.i2c.readfrom_into(self.addr, self.buf1)
                n = self.buf1[0]
                break

            

Reported by Pylint.

                              n = self.buf1[0]
                break
            except OSError as er:
                time.sleep_us(500)
            if time.ticks_diff(time.ticks_ms(), start) > 5000:
                raise Exception("timeout")
        if n >= 129:
            raise Exception(n)
        if n == 0:

            

Reported by Pylint.

                              break
            except OSError as er:
                time.sleep_us(500)
            if time.ticks_diff(time.ticks_ms(), start) > 5000:
                raise Exception("timeout")
        if n >= 129:
            raise Exception(n)
        if n == 0:
            return b""

            

Reported by Pylint.

                              break
            except OSError as er:
                time.sleep_us(500)
            if time.ticks_diff(time.ticks_ms(), start) > 5000:
                raise Exception("timeout")
        if n >= 129:
            raise Exception(n)
        if n == 0:
            return b""

            

Reported by Pylint.

                      local_sha = hashlib.sha256()
        print("Deploying %s to location 0x%08x" % (filename, addr))
        with open(filename, "rb") as f:
            t0 = time.ticks_ms()
            while True:
                n = f.readinto(buf)
                if n == 0:
                    break


            

Reported by Pylint.

                              ntotal = addr - start_addr
                if ntotal % 2048 == 0 or ntotal == fsize:
                    print("\r% 3u%% % 7u bytes   " % (100 * ntotal // fsize, ntotal), end="")
            t1 = time.ticks_ms()
        print()
        print("rate: %.2f KiB/sec" % (1024 * ntotal / (t1 - t0) / 1000))

        local_sha = local_sha.digest()
        print("Local SHA256: ", "".join("%02x" % x for x in local_sha))

            

Reported by Pylint.

                      try:
            self.i2c.writeto(addr, b"")
        except OSError:
            raise Exception("no I2C mboot device found")

    def wait_response(self):
        start = time.ticks_ms()
        while 1:
            try:

            

Reported by Pylint.

                              self.i2c.readfrom_into(self.addr, self.buf1)
                n = self.buf1[0]
                break
            except OSError as er:
                time.sleep_us(500)
            if time.ticks_diff(time.ticks_ms(), start) > 5000:
                raise Exception("timeout")
        if n >= 129:
            raise Exception(n)

            

Reported by Pylint.

                  def getlayout(self):
        self.i2c.writeto(self.addr, struct.pack("<B", I2C_CMD_GETLAYOUT))
        layout = self.wait_response()
        id, flash_addr, layout = layout.split(b"/")
        assert id == b"@Internal Flash  "
        flash_addr = int(flash_addr, 16)
        pages = []
        for chunk in layout.split(b","):
            n, sz = chunk.split(b"*")

            

Reported by Pylint.

                          n = int(n)
            assert sz.endswith(b"Kg")
            sz = int(sz[:-2]) * 1024
            for i in range(n):
                pages.append((flash_addr, sz))
                flash_addr += sz
        return pages

    def pageerase(self, addr):

            

Reported by Pylint.