typify() - Code Metrics - Inspection of "allow boolify to return None" - kalefranz/auxlib - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — develop ( 40eca3...d2744c )

by Kale

created 2016-07-22 19:28 UTC

typify() C

↳ Parent: Project

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	4
Bugs	1	Features	0

Metric	Value
cc	10
c	4
b	1
f	0
dl	0
loc	55
rs	5.1428

How to fix Long Method Complexity

"""Collection of functions to coerce conversion of types with an intelligent guess."""
from itertools import chain
from collections import Mapping
from re import compile, IGNORECASE
from .compat import integer_types, string_types, text_type, isiterable, iteritems, NoneType
from .decorators import memoize, memoizeproperty

__all__ = ["boolify", "typify", "maybecall", "listify", "numberify"]

BOOLISH_TRUE = ("true", "yes", "on", "y")
BOOLISH_FALSE = ("false", "off", "n", "no", "non", "none", "")
NULL_STRINGS = ("none", "~", "null", "\0")
BOOL_COERCEABLE_TYPES = integer_types + (bool, float, complex, list, set, dict, tuple)
NUMBER_TYPES = integer_types + (float, complex)
NUMBER_TYPES_SET = set(NUMBER_TYPES)
STRING_TYPES_SET = set(string_types)
BOOLNULL_TYPE_SET = set((bool, NoneType))

NO_MATCH = object()


class _Regex(object):

    @memoizeproperty
    def BOOLEAN_TRUE(self):
        return compile(r'^true$|^yes$|^on$', IGNORECASE), True

    @memoizeproperty
    def BOOLEAN_FALSE(self):
        return compile(r'^false$|^no$|^off$', IGNORECASE), False

    @memoizeproperty
    def NONE(self):
        return compile(r'^none$|^null$', IGNORECASE), None

    @memoizeproperty
    def INT(self):
        return compile(r'^[-+]?\d+$'), int

    @memoizeproperty
    def BIN(self):
        return compile(r'^[-+]?0[bB][01]+$'), bin

    @memoizeproperty
    def OCT(self):
        return compile(r'^[-+]?0[oO][0-7]+$'), oct

    @memoizeproperty
    def HEX(self):
        return compile(r'^[-+]?0[xX][0-9a-fA-F]+$'), hex

    @memoizeproperty
    def FLOAT(self):
        return compile(r'^[-+]?(\d+(\.\d*)?|\.\d+)([eE][-+]?\d+)?$'), float

    @memoizeproperty
    def COMPLEX(self):
        return (compile(r'^(?:[-+]?(\d+(\.\d*)?|\.\d+)([eE][-+]?\d+)?)?'  # maybe first float
                        r'[-+]?(\d+(\.\d*)?|\.\d+)([eE][-+]?\d+)?j$'),     # second float with j
                complex)

    @property
    def numbers(self):
        yield self.INT
        yield self.FLOAT
        yield self.BIN
        yield self.OCT
        yield self.HEX
        yield self.COMPLEX

    @property
    def boolean(self):
        yield self.BOOLEAN_TRUE
        yield self.BOOLEAN_FALSE

    @property
    def none(self):
        yield self.NONE

    def convert_number(self, value_string):
        return self._convert(value_string, (self.numbers, ))

    def convert(self, value_string):
        return self._convert(value_string, (self.boolean, self.none, self.numbers, ))

    def _convert(self, value_string, type_list):
        return next((typish(value_string) if callable(typish) else typish
                     for regex, typish in chain.from_iterable(type_list)
                     if regex.match(value_string)),
                    NO_MATCH)

_REGEX = _Regex()


def numberify(value):
    """

    Examples:
        >>> [numberify(x) for x in ('1234', 1234, '0755', 0o0755, False, 0, '0', True, 1, '1')]
          [1234, 1234, 755, 493, 0, 0, 0, 1, 1, 1]
        >>> [numberify(x) for x in ('12.34', 12.34, 1.2+3.5j, '1.2+3.5j')]
        [12.34, 12.34, (1.2+3.5j), (1.2+3.5j)]

    """
    if isinstance(value, bool):
        return int(value)
    if isinstance(value, NUMBER_TYPES):
        return value
    candidate = _REGEX.convert_number(value)
    if candidate is not NO_MATCH:
        return candidate
    raise ValueError("Cannot convert {0} to a number.".format(value))


def boolify(value, nullable=False):
    """Convert a number, string, or sequence type into a pure boolean.

    Args:
        value (number, string, sequence): pretty much anything

    Returns:
        bool: boolean representation of the given value

    Examples:
        >>> [boolify(x) for x in ('yes', 'no')]
        [True, False]
        >>> [boolify(x) for x in (0.1, 0+0j, True, '0', '0.0', '0.1', '2')]
        [True, False, True, False, False, True, True]
        >>> [boolify(x) for x in ("true", "yes", "on", "y")]
        [True, True, True, True]
        >>> [boolify(x) for x in ("no", "non", "none", "off", "")]
        [False, False, False, False, False]
        >>> [boolify(x) for x in ([], set(), dict(), tuple())]
        [False, False, False, False]
        >>> [boolify(x) for x in ([1], set([False]), dict({'a': 1}), tuple([2]))]
        [True, True, True, True]

    """
    # cast number types naturally
    if isinstance(value, BOOL_COERCEABLE_TYPES):
        return bool(value)
    # try to coerce string into number
    val = text_type(value).strip().lower().replace('.', '', 1)
    if val.isnumeric():
        return bool(float(val))
    elif val in BOOLISH_TRUE:
        return True
    elif nullable and val in NULL_STRINGS:
        return None
    elif val in BOOLISH_FALSE:
        return False
    else:  # must be False
        try:
            return bool(complex(val))
        except ValueError:
            raise ValueError("The value {0} cannot be boolified.".format(repr(value)))


def boolify_truthy_string_ok(value):
    try:
        return boolify(value)
    except ValueError:
        assert isinstance(value, string_types), repr(value)
        return True


@memoize
def typify(value, type_hint=None):
    """Take a primitive value, usually a string, and try to make a more relevant type out of it.
    An optional type_hint will try to coerce the value to that type.

    Args:
        value (Any): Usually a string, not a sequence
        type_hint (type or Tuple[type]):

    Examples:
        >>> typify('32')
        32
        >>> typify('32', float)
        32.0
        >>> typify('32.0')
        32.0
        >>> typify('32.0.0')
        '32.0.0'
        >>> [typify(x) for x in ('true', 'yes', 'on')]
        [True, True, True]
        >>> [typify(x) for x in ('no', 'FALSe', 'off')]
        [False, False, False]
        >>> [typify(x) for x in ('none', 'None', None)]
        [None, None, None]

    """
    # value must be a string, or there at least needs to be a type hint
    if isinstance(value, string_types):
        value = value.strip()
    elif type_hint is None:
        # can't do anything because value isn't a string and there's no type hint
        return value

    # now we either have a stripped string, a type hint, or both
    # use the hint if it exists
    if isiterable(type_hint):
        type_hint = set(type_hint)
        if not (type_hint - NUMBER_TYPES_SET):
            return numberify(value)
        elif not (type_hint - STRING_TYPES_SET):
            return text_type(value)
        elif not (type_hint - BOOLNULL_TYPE_SET):
            return boolify(value, nullable=True)
        raise NotImplementedError()
    elif type_hint is not None:
        # coerce using the type hint, or use boolify for bool
        return boolify(value) if type_hint == bool else type_hint(value)
    else:
        # no type hint, but we know value is a string, so try to match with the regex patterns
        candidate = _REGEX.convert(value)
        if candidate is not NO_MATCH:
            return candidate

        # nothing has caught so far; give up, and return the value that was given
        return value


def typify_data_structure(value, type_hint=None):
    if isinstance(value, Mapping):
        return type(value)((k, typify(v, type_hint)) for k, v in iteritems(value))
    elif isiterable(value):
        return type(value)(typify(v, type_hint) for v in value)
    else:
        return typify(value, type_hint)


def maybecall(value):
    return value() if callable(value) else value


def listify(val, return_type=tuple):
    """
    Examples:
        >>> listify('abc', return_type=list)
        ['abc']
        >>> listify(None)
        ()
        >>> listify(False)
        (False,)
        >>> listify(('a', 'b', 'c'), return_type=list)
        ['a', 'b', 'c']
    """
    # TODO: flatlistify((1, 2, 3), 4, (5, 6, 7))
    if val is None:
        return return_type()
    elif isiterable(val):
        return return_type(val)
    else:
        return return_type((val, ))


1			"""Collection of functions to coerce conversion of types with an intelligent guess."""
2			from itertools import chain
3			from collections import Mapping
4			from re import compile, IGNORECASE
5			from .compat import integer_types, string_types, text_type, isiterable, iteritems, NoneType
6			from .decorators import memoize, memoizeproperty
7
8			__all__ = ["boolify", "typify", "maybecall", "listify", "numberify"]
9
10			BOOLISH_TRUE = ("true", "yes", "on", "y")
11			BOOLISH_FALSE = ("false", "off", "n", "no", "non", "none", "")
12			NULL_STRINGS = ("none", "~", "null", "\0")
13			BOOL_COERCEABLE_TYPES = integer_types + (bool, float, complex, list, set, dict, tuple)
14			NUMBER_TYPES = integer_types + (float, complex)
15			NUMBER_TYPES_SET = set(NUMBER_TYPES)
16			STRING_TYPES_SET = set(string_types)
17			BOOLNULL_TYPE_SET = set((bool, NoneType))
18
19			NO_MATCH = object()
20
21
22			class _Regex(object):
23
24			@memoizeproperty
25			def BOOLEAN_TRUE(self):
26			return compile(r'^true$\|^yes$\|^on$', IGNORECASE), True
27
28			@memoizeproperty
29			def BOOLEAN_FALSE(self):
30			return compile(r'^false$\|^no$\|^off$', IGNORECASE), False
31
32			@memoizeproperty
33			def NONE(self):
34			return compile(r'^none$\|^null$', IGNORECASE), None
35
36			@memoizeproperty
37			def INT(self):
38			return compile(r'^[-+]?\d+$'), int
39
40			@memoizeproperty
41			def BIN(self):
42			return compile(r'^[-+]?0[bB][01]+$'), bin
43
44			@memoizeproperty
45			def OCT(self):
46			return compile(r'^[-+]?0[oO][0-7]+$'), oct
47
48			@memoizeproperty
49			def HEX(self):
50			return compile(r'^[-+]?0[xX][0-9a-fA-F]+$'), hex
51
52			@memoizeproperty
53			def FLOAT(self):
54			return compile(r'^[-+]?(\d+(\.\d*)?\|\.\d+)([eE][-+]?\d+)?$'), float
55
56			@memoizeproperty
57			def COMPLEX(self):
58			return (compile(r'^(?:[-+]?(\d+(\.\d*)?\|\.\d+)([eE][-+]?\d+)?)?' # maybe first float
59			r'[-+]?(\d+(\.\d*)?\|\.\d+)([eE][-+]?\d+)?j$'), # second float with j
60			complex)
61
62			@property
63			def numbers(self):
64			yield self.INT
65			yield self.FLOAT
66			yield self.BIN
67			yield self.OCT
68			yield self.HEX
69			yield self.COMPLEX
70
71			@property
72			def boolean(self):
73			yield self.BOOLEAN_TRUE
74			yield self.BOOLEAN_FALSE
75
76			@property
77			def none(self):
78			yield self.NONE
79
80			def convert_number(self, value_string):
81			return self._convert(value_string, (self.numbers, ))
82
83			def convert(self, value_string):
84			return self._convert(value_string, (self.boolean, self.none, self.numbers, ))
85
86			def _convert(self, value_string, type_list):
87			return next((typish(value_string) if callable(typish) else typish
88			for regex, typish in chain.from_iterable(type_list)
89			if regex.match(value_string)),
90			NO_MATCH)
91
92			_REGEX = _Regex()
93
94
95			def numberify(value):
96			"""
97
98			Examples:
99			>>> [numberify(x) for x in ('1234', 1234, '0755', 0o0755, False, 0, '0', True, 1, '1')]
100			[1234, 1234, 755, 493, 0, 0, 0, 1, 1, 1]
101			>>> [numberify(x) for x in ('12.34', 12.34, 1.2+3.5j, '1.2+3.5j')]
102			[12.34, 12.34, (1.2+3.5j), (1.2+3.5j)]
103
104			"""
105			if isinstance(value, bool):
106			return int(value)
107			if isinstance(value, NUMBER_TYPES):
108			return value
109			candidate = _REGEX.convert_number(value)
110			if candidate is not NO_MATCH:
111			return candidate
112			raise ValueError("Cannot convert {0} to a number.".format(value))
113
114
115			def boolify(value, nullable=False):
116			"""Convert a number, string, or sequence type into a pure boolean.
117
118			Args:
119			value (number, string, sequence): pretty much anything
120
121			Returns:
122			bool: boolean representation of the given value
123
124			Examples:
125			>>> [boolify(x) for x in ('yes', 'no')]
126			[True, False]
127			>>> [boolify(x) for x in (0.1, 0+0j, True, '0', '0.0', '0.1', '2')]
128			[True, False, True, False, False, True, True]
129			>>> [boolify(x) for x in ("true", "yes", "on", "y")]
130			[True, True, True, True]
131			>>> [boolify(x) for x in ("no", "non", "none", "off", "")]
132			[False, False, False, False, False]
133			>>> [boolify(x) for x in ([], set(), dict(), tuple())]
134			[False, False, False, False]
135			>>> [boolify(x) for x in ([1], set([False]), dict({'a': 1}), tuple([2]))]
136			[True, True, True, True]
137
138			"""
139			# cast number types naturally
140			if isinstance(value, BOOL_COERCEABLE_TYPES):
141			return bool(value)
142			# try to coerce string into number
143			val = text_type(value).strip().lower().replace('.', '', 1)
144			if val.isnumeric():
145			return bool(float(val))
146			elif val in BOOLISH_TRUE:
147			return True
148			elif nullable and val in NULL_STRINGS:
149			return None
150			elif val in BOOLISH_FALSE:
151			return False
152			else: # must be False
153			try:
154			return bool(complex(val))
155			except ValueError:
156			raise ValueError("The value {0} cannot be boolified.".format(repr(value)))
157
158
159			def boolify_truthy_string_ok(value):
160			try:
161			return boolify(value)
162			except ValueError:
163			assert isinstance(value, string_types), repr(value)
164			return True
165
166
167			@memoize
168			def typify(value, type_hint=None):
169			"""Take a primitive value, usually a string, and try to make a more relevant type out of it.
170			An optional type_hint will try to coerce the value to that type.
171
172			Args:
173			value (Any): Usually a string, not a sequence
174			type_hint (type or Tuple[type]):
175
176			Examples:
177			>>> typify('32')
178			32
179			>>> typify('32', float)
180			32.0
181			>>> typify('32.0')
182			32.0
183			>>> typify('32.0.0')
184			'32.0.0'
185			>>> [typify(x) for x in ('true', 'yes', 'on')]
186			[True, True, True]
187			>>> [typify(x) for x in ('no', 'FALSe', 'off')]
188			[False, False, False]
189			>>> [typify(x) for x in ('none', 'None', None)]
190			[None, None, None]
191
192			"""
193			# value must be a string, or there at least needs to be a type hint
194			if isinstance(value, string_types):
195			value = value.strip()
196			elif type_hint is None:
197			# can't do anything because value isn't a string and there's no type hint
198			return value
199
200			# now we either have a stripped string, a type hint, or both
201			# use the hint if it exists
202			if isiterable(type_hint):
203			type_hint = set(type_hint)
204			if not (type_hint - NUMBER_TYPES_SET):
205			return numberify(value)
206			elif not (type_hint - STRING_TYPES_SET):
207			return text_type(value)
208			elif not (type_hint - BOOLNULL_TYPE_SET):
209			return boolify(value, nullable=True)
210			raise NotImplementedError()
211			elif type_hint is not None:
212			# coerce using the type hint, or use boolify for bool
213			return boolify(value) if type_hint == bool else type_hint(value)
214			else:
215			# no type hint, but we know value is a string, so try to match with the regex patterns
216			candidate = _REGEX.convert(value)
217			if candidate is not NO_MATCH:
218			return candidate
219
220			# nothing has caught so far; give up, and return the value that was given
221			return value
222
223
224			def typify_data_structure(value, type_hint=None):
225			if isinstance(value, Mapping):
226			return type(value)((k, typify(v, type_hint)) for k, v in iteritems(value))
227			elif isiterable(value):
228			return type(value)(typify(v, type_hint) for v in value)
229			else:
230			return typify(value, type_hint)
231
232
233			def maybecall(value):
234			return value() if callable(value) else value
235
236
237			def listify(val, return_type=tuple):
238			"""
239			Examples:
240			>>> listify('abc', return_type=list)
241			['abc']
242			>>> listify(None)
243			()
244			>>> listify(False)
245			(False,)
246			>>> listify(('a', 'b', 'c'), return_type=list)
247			['a', 'b', 'c']
248			"""
249			# TODO: flatlistify((1, 2, 3), 4, (5, 6, 7))
250			if val is None:
251			return return_type()
252			elif isiterable(val):
253			return return_type(val)
254			else:
255			return return_type((val, ))
256

kalefranz / auxlib

Push — develop ( 40eca3...d2744c )

typify() C

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Complexity

Duplication Side-by-Side

Filter issues like