UART._invoke_mapping() - Code Metrics - s-s-boika/obdlib - Measure and Improve Code Quality continuously with Scrutinizer

UART._invoke_mapping() A
last analyzed 2017-02-09 09:22 UTC

↳ Parent: UART

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	4
Bugs	0	Features	0

Metric	Value
c	4
b	0
f	0
dl	0
loc	7
rs	9.4285
cc	3

DEFAULT_BAUDRATE = 38400
import sys

if (hasattr(sys, 'implementation') and
            sys.implementation.name == 'micropython'):
    # if using pyBoard
    from pyb import UART as uart_base
else:
    from serial import Serial as uart_base

from obdlib.logging import logger


class UART(object):
    def __init__(self):
        self.bus_name = uart_base.__name__
        self.bus = None
        self.map = {}

    def connection(self, port, baudrate=DEFAULT_BAUDRATE):
        try:
            self.bus = uart_base(port, baudrate)
            self._mapping()
        except Exception as err:
            # logging exception
            logger.error(err)
            return None

        return self

    def __getattr__(self, item):
        def args_wrapper(*args, **kwargs):
            try:
                response = getattr(self.bus, item)(*args, **kwargs)
            except AttributeError:
                response = self._invoke_mapping(item, *args, **kwargs)
            return response

        return args_wrapper

    def _invoke_mapping(self, method, *args, **kwargs):
        try:
            item = self.map[self.bus_name][method]
            return getattr(self.bus, item)(*args, **kwargs) if item else None
        except KeyError:
            raise Exception(
                "Unregistered method or attribute {}".format(method))

    def _mapping(self):
        self.map = {
            "UART": {
                "close": "deinit",
                "flushInput": "",
                "flushOutput": ""
            },
        }


1			DEFAULT_BAUDRATE = 38400
2			import sys
3
4			if (hasattr(sys, 'implementation') and
5			sys.implementation.name == 'micropython'):
6			# if using pyBoard
7			from pyb import UART as uart_base
8			else:
9			from serial import Serial as uart_base
10
11			from obdlib.logging import logger
12
13
14			class UART(object):
15			def __init__(self):
16			self.bus_name = uart_base.__name__
17			self.bus = None
18			self.map = {}
19
20			def connection(self, port, baudrate=DEFAULT_BAUDRATE):
21			try:
22			self.bus = uart_base(port, baudrate)
23			self._mapping()
24			except Exception as err:
25			# logging exception
26			logger.error(err)
27			return None
28
29			return self
30
31			def __getattr__(self, item):
32			def args_wrapper(args, *kwargs):
33			try:
34			response = getattr(self.bus, item)(args, *kwargs)
35			except AttributeError:
36			response = self._invoke_mapping(item, args, *kwargs)
37			return response
38
39			return args_wrapper
40
41			def _invoke_mapping(self, method, args, *kwargs):
42			try:
43			item = self.map[self.bus_name][method]
44			return getattr(self.bus, item)(args, *kwargs) if item else None
45			except KeyError:
46			raise Exception(
47			"Unregistered method or attribute {}".format(method))
48
49			def _mapping(self):
50			self.map = {
51			"UART": {
52			"close": "deinit",
53			"flushInput": "",
54			"flushOutput": ""
55			},
56			}
57

s-s-boika / obdlib

UART._invoke_mapping() A last analyzed 2017-02-09 09:22 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

UART._invoke_mapping() A
last analyzed 2017-02-09 09:22 UTC