batutils 2.0.0__py3-none-any.whl

batutils/structs/_base.py

@@ -0,0 +1,21 @@
+"""These are the modules used by most of the code in this package.
+
+This is intended for internal use only and is meant to simplify the otherwise
+repetitive importing of the same modules over and over again in most of the
+python files here.
+
+I.e. instead of starting most files with the same imports as here, you just go:
+```python
+from batutils.structs import *  # This includes the `_base`
+```
+"""
+from typing import *
+
+from decimal import Decimal
+
+import abc
+import dataclasses
+import enum
+import logging
+import re
+import time

batutils/tpu/casting/__init__.py

@@ -0,0 +1,9 @@
+from batutils._common import decode_bytes  # noqa
+from batutils.tpu.structs.serializers import *
+
+from ._evals import *
+from ._ip import *
+from ._mask import *
+from ._params import *
+from ._currency import *
+from ._serialize import *

batutils/tpu/casting/_currency.py

@@ -0,0 +1,52 @@
+__all__ = [
+    'parse_currency_text',
+]
+
+from batutils.tpu.structs import *
+
+
+_CURRENCY_REGEX = re.compile(r'(?i)^(?P<curr1>(?:[^0-9 \+\-])*)? *(?P<sign1>[\+\-])? *(?P<amount>(?:[0-9]|[\.\,])+) *(?P<sign2>[\+\-])? *(?P<curr2>(?:[^0-9 \+\-])*)?$')
+
+
+def parse_currency_text(text: str) -> Tuple[Optional[str], Optional[float]]:
+    """Parses a text in the form "CURRENCY (+|-) AMOUNT" into a two-tuple of string and float if possible.
+
+    :param text:
+    :type text:
+    :return:
+    :rtype:
+    """
+    from batutils.tpu.casting import float_eval
+    m = _CURRENCY_REGEX.match(text)
+    if m:
+        currency = ''
+        curr1 = m.group('curr1')
+        curr2 = m.group('curr2')
+        if curr1:
+            if curr2:
+                if curr1.lower() == curr2.lower():
+                    currency = curr1
+                else:
+                    currency = '%s/%s' % (curr1, curr2)
+            else:
+                currency = curr1
+        elif curr2:
+            currency = curr2
+
+        neg = False
+        sign1 = m.group('sign1')
+        sign2 = m.group('sign2')
+        if sign1 and sign1 == '-':
+            neg = True
+        elif sign2 and sign2 == '-':
+            neg = True
+
+        amount = 0.0
+        amount_text = m.group('amount').replace(',', '')
+        if amount_text:
+            amount = float_eval(amount_text)
+        if neg:
+            amount = -amount
+        return currency, amount
+
+    return None, None

batutils/tpu/casting/_evals.py

@@ -0,0 +1,247 @@
+__all__ = [
+    'float_eval',
+    'int_eval',
+    'bool_eval',
+    'enum_eval',
+
+    'decode_bytes',
+]
+
+from batutils.tpu.structs import *
+from batutils._common import decode_bytes  # noqa
+
+_AFFIRMATIVE = {
+    'active',
+    'enable',
+    'enabled',
+    'on',
+    'true',
+    'yes',
+    'y',
+}
+
+_T_ENUM_CLASS = TypeVar('T_ENUM_CLASS', bound=enum.Enum)
+
+
+def float_eval(value: Any, default: Union[float, None] = 0.0, raise_on_fail: bool = False) -> Union[float, None]:
+    """Safe evaluation of any type to a float value. The optional default value
+    will be returned on any parsing or casting error. You can also pass None as
+    the default to check for failures.
+
+    Adding the raise_on_fail parameter and setting it to True will cause the
+    method to raise TypeError or ValueError exceptions if it fails to evaluate a
+    float value from the value given.
+
+    Useful shortcut where you have a string that you're know is a float value
+    in string form like prefs entries, DB entries from varchar fields or HTTP
+    GET/POST arguments
+
+    :type value: any
+    :type default: float or None
+    :type raise_on_fail: bool
+    :rtype: float or None
+    """
+    if isinstance(value, float):
+        return value  # Duh!
+    elif isinstance(value, int):
+        return float(value)
+    elif isinstance(value, (str, bytes)):
+        try:
+            return float(value)
+        except (TypeError, ValueError):
+            if raise_on_fail:
+                raise
+            return default
+    elif isinstance(value, datetime.timedelta):
+        return value.total_seconds()
+    elif isinstance(value, datetime.date):  # datetime.datetime extends datetime date
+        return time.mktime(value.timetuple())
+    elif isinstance(value, datetime.time):
+        return float(value.hour * 3600 + value.minute * 60 + value.second + value.microsecond * 0.000001)
+    else:
+        try:
+            # Let's just try and pass this through the float caster...?
+            return float(value)
+        except (TypeError, ValueError):
+            pass
+
+        if raise_on_fail:
+            raise TypeError(f'Could not evaluate unknown type [{type(value)}] to a float value')
+        return default
+
+
+def int_eval(value: Any, default: Union[int, None] = 0, raise_on_fail: bool = False) -> Union[int, None]:
+    """Safe evaluation of any type to an int value. The optional default value
+    will be returned on any parsing or casting error. You can also pass None as
+    the default to check for failures.
+
+    Long values that contain values larger than ints can contain (or strings
+    containing such values) will evaluate to a long.
+
+    Useful shortcut where you have a string that you're know is an int value
+    in string form like prefs entries, DB entries from varchar fields or HTTP
+    GET/POST arguments
+
+    :type value: any
+    :type default: int or None
+    :type raise_on_fail: bool
+    :rtype: int or long or None
+    """
+    if isinstance(value, int):
+        return value  # Duh!
+
+    elif isinstance(value, float):
+        return int(value)
+
+    elif isinstance(value, (str, bytes)):
+        try:
+            return int(value, base=0)
+
+        except (TypeError, ValueError):
+            try:
+                return int(float(value))
+
+            except (TypeError, ValueError):
+                if raise_on_fail:
+                    raise
+
+                return default
+
+    elif isinstance(value, datetime.timedelta):
+        return int(value.total_seconds())
+
+    elif isinstance(value, datetime.date):  # datetime.datetime extends datetime date
+        return int(time.mktime(value.timetuple()))
+
+    elif isinstance(value, datetime.time):
+        return int(value.hour * 3600 + value.minute * 60 + value.second)
+
+    else:
+        try:
+            # Let's just try and pass this through the float caster...?
+            return int(value)
+        except (TypeError, ValueError):
+            pass
+
+    if raise_on_fail:
+        raise TypeError(f'Could not evaluate unknown type [{type(value)}] to an int value')
+
+    return default
+
+
+def bool_eval(value: Any, raise_on_fail: bool = False) -> bool:
+    """Evaluates if a value should be interpreted as a boolean True value.
+    That means a string that is "True" (or other explicit affirmative words)
+    regardless of case and whitespace characters as well as any numerical value
+    other than 0 and of course a boolean type of true.
+
+    Anything else returns False, including all objects.
+
+    Boolean types are return their same value.
+
+    Strings and bytes with the following values will (case insensitive) evaluate to True:
+    - active
+    - enable
+    - enabled
+    - on
+    - true
+    - yes
+    - y
+
+    Strings and unicode strings that are longs, integers or floats evaluate to
+    the same as their "pure" types (int, float) would evaluate to.
+
+    Longs, Integers and Floating number evaluate to False if they are 0L, 0 and
+    0.0 respectively, anything else is True.
+
+    Any other type or object yield a False return (the opposite of what Python
+    does by default, because we're looking for explicit statements of "Yes!")
+
+    Very useful for evaluating values read from prefs.ini that can use
+    different formats.
+
+    :type value: any
+    :type raise_on_fail: bool
+    :rtype: bool
+    """
+    if isinstance(value, bool):
+        return value  # Duh!
+
+    if isinstance(value, bytes):
+        try:
+            value = decode_bytes(value)
+        except ValueError:
+            if raise_on_fail:
+                raise
+            return False
+
+    if isinstance(value, str):
+        value = value.strip().lower()
+        if value in _AFFIRMATIVE:
+            return True
+
+        elif value.isdigit():
+            return bool(int(value))
+
+        else:
+            neg = False
+            if value.startswith('-'):
+                value = value[1:]
+                neg = True
+                if value.isdigit():
+                    return bool(-int(value))
+            parts = value.split('.')
+            if len(parts) == 2:
+                if parts[0].isdigit() and parts[1].isdigit():
+                    if neg:
+                        return bool(-float(value))
+                    else:
+                        return bool(float(value))
+            return False
+    elif isinstance(value, (int, float)):
+        return bool(value)
+    else:
+        return False
+
+
+def enum_eval(value: Any,
+              enum_class: Type[_T_ENUM_CLASS],
+              default: Union[_T_ENUM_CLASS, None] = None,
+              raise_on_fail: bool = False) -> _T_ENUM_CLASS:
+    if isinstance(value, enum_class):
+        return value
+
+    if isinstance(value, enum.Enum):
+        value = value.value
+
+    if isinstance(value, bytes):
+        try:
+            value = decode_bytes(value)
+        except ValueError:
+            if raise_on_fail:
+                raise
+            return default
+
+    if isinstance(value, str):
+        hit = {o.name.lower(): o for o in enum_class}.get(value.strip().lower(), None)
+        if hit is not None:
+            return hit
+        try:
+            value = int(value, base=0)
+        except ValueError:
+            if raise_on_fail:
+                raise ValueError(f'{value!r} is not a valid {enum_class.__name__}')
+            return default
+
+    if isinstance(value, int):
+        try:
+            return enum_class(value)
+        except ValueError:
+            if raise_on_fail:
+                raise
+            return default
+
+    if raise_on_fail:
+        raise ValueError(f'{value!r} is not a valid {enum_class.__name__}')
+
+    return default

batutils/tpu/casting/_ip.py

@@ -0,0 +1,58 @@
+__all__ = [
+    'ip_to_int',
+    'int_to_ip',
+]
+
+
+def ip_to_int(ip):
+    """
+
+    :param ip:
+    :type ip: str
+    :return:
+    :rtype: int
+    :raises ValueError: If the given string is not a valid IP address
+    """
+    parts = ip.split('.')
+    if len(parts) != 4:
+        raise ValueError('Not a valid IP address')
+    i = 0
+
+    ii = int(parts[0])
+    if ii < 0 or ii > 255:
+        raise ValueError('Not a valid IP address')
+    i += ii << 24
+
+    ii = int(parts[1])
+    if ii < 0 or ii > 255:
+        raise ValueError('Not a valid IP address')
+    i += ii << 16
+
+    ii = int(parts[2])
+    if ii < 0 or ii > 255:
+        raise ValueError('Not a valid IP address')
+    i += ii << 8
+
+    ii = int(parts[3])
+    if ii < 0 or ii > 255:
+        raise ValueError('Not a valid IP address')
+    i += ii
+
+    return i
+
+
+def int_to_ip(i):
+    """
+
+    :param i:
+    :type i: int
+    :return:
+    :rtype: str
+    """
+    d = i & 0xFF
+    i >>= 8
+    c = i & 0xFF
+    i >>= 8
+    b = i & 0xFF
+    a = i >> 8
+    return '%s.%s.%s.%s' % (a, b, c, d)

batutils/tpu/casting/_mask.py

@@ -0,0 +1,34 @@
+__all__ = [
+    'split_bitmask',
+]
+
+
+def split_bitmask(composite_value):
+    """Takes an int or long value representing a composite bitmask and returns
+    a list of the individual bit flag values contained in the mask.
+
+    Put another way, this splits a number into it's "power-of-two" components.
+
+    Examples:
+    ---------
+
+        >>> split_bitmask(1)
+        [1]
+        >>> split_bitmask(12)
+        [4, 8]
+        >>> split_bitmask(123)
+        [1, 2, 8, 16, 32, 64]
+
+    :param composite_value:
+    :type composite_value:
+    :return:
+    :rtype:
+    """
+    buff = []
+    bitval = 1
+    while composite_value > 0:
+        if composite_value & 1:
+            buff.append(bitval)
+        bitval *= 2
+        composite_value >>= 1
+    return buff

batutils/tpu/casting/_params.py

@@ -0,0 +1,108 @@
+__all__ = [
+    'Params',
+    'parse_params',
+]
+
+from batutils.tpu.structs import *
+
+_KW_ARG_MATCHER = re.compile(r'(\w+)=(.+)')
+
+
+class Params(object):
+    __slots__ = ('args', 'kwargs', 'props')
+
+    def __init__(self, args=None, kwargs=None, props=None):
+        self.args = args or []
+        self.kwargs = kwargs or {}
+        self.props = props or {}
+
+    def __repr__(self):
+        return u'Params(args=%r, kwargs=%r, props=%r)' % (self.args, self.kwargs, self.props)
+
+    def __unicode__(self):
+        return self.__repr__()
+
+    def __eq__(self, other):
+        if isinstance(other, Params):
+            return all([self.args == other.args,
+                        self.kwargs == other.kwargs,
+                        self.props == other.props])
+        return False
+
+
+def parse_params(params: Union[List[str], str],
+                 list_of_props: Optional[List[str]] = None,
+                 props_as_kw_dict: Optional[Dict[str, List[str]]] = None,
+                 matcher: Optional[Union[re.Pattern, str]] = None):
+    """Takes a list of string parameters or a single string with multiple
+    parameters (e.g. from command line input or template tag calls) and splits
+    up into numbered arguments, keyword arguments and property flags.
+
+    >>> parse_params(['foo', 'bar=7', 'debug'], ['debug', 'vocal'])
+    Params(args=['foo'], kwargs={'bar': '7'}, props={'debug': True, 'vocal': False})
+
+    Parameters that are in a key/val format determined by the given regex
+    matcher (defaults to "(\\w+)=(.+)" or just "key=val") will populate the
+    kwargs property of the returned Param object.
+
+    Other parameters will either get passed into the args
+    list (in order) of the returned Param object or trigger the value of the key
+    in the props dict of the returned Param object to be true if that param
+    value is in the given list_of_props.
+
+    All other values in list_of_props will be represented as keys in the props
+    dict with the value False.
+
+    The props_as_kw_dict optionally takes in a dict of string keys and a list of
+    string values that will be searched in the parameter list and if found, the
+    value will be paired with the key in the `props_as_kw_dict` and added to the
+    returned Param object as a `kwargs` pair.
+
+    >>> parse_params('foo bar warning', props_as_kw_dict={'log_level': ['info', 'warning', 'error']})
+    Params(args=['foo', 'bar'], kwargs={'log_level': 'warning'}, props={})
+
+    :param params:
+    :type params: list
+    :param list_of_props:
+    :type list_of_props: list | None
+    :param props_as_kw_dict:
+    :type props_as_kw_dict: dict | None
+    :param matcher:
+    :type matcher: re._pattern_type
+    :return:
+    :rtype: ccptools.tpu.casting.Params
+    """
+    from batutils.tpu.string import dequote
+
+    matcher = matcher or _KW_ARG_MATCHER
+    if isinstance(matcher, str):
+        matcher = re.compile(matcher)
+
+    if isinstance(params, str):
+        params = params.split()
+
+    list_of_props = list_of_props or []
+    props_as_kw_dict = props_as_kw_dict or {}
+    if props_as_kw_dict:
+        for p_list in props_as_kw_dict.values():
+            list_of_props.extend(p_list)
+
+    p = Params(props=dict(zip(list_of_props, [False]*len(list_of_props))))
+    for a in params:
+        m = matcher.match(a)
+        if m:
+            p.kwargs[m.group(1)] = dequote(m.group(2))
+        else:
+            if a in list_of_props:
+                p.props[a] = True
+            else:
+                p.args.append(dequote(a))
+
+    if props_as_kw_dict:
+        for keyword, p_list in props_as_kw_dict.items():
+            if keyword not in p.kwargs:
+                p.kwargs[keyword] = None
+                for p_name in p_list:
+                    if p.props.pop(p_name, False):
+                        p.kwargs[keyword] = p_name
+    return p

batutils/tpu/casting/_serialize.py

@@ -0,0 +1,20 @@
+__all__ = [
+    'any_to_json',
+]
+
+
+from batutils.tpu.structs import *
+from batutils.tpu.structs.serializers import *
+
+_serializer = JsonSerializer()
+
+
+def any_to_json(anything: Any, skip_keys=None, skip_values=None, skip_private=True, skip_nones=False, skip_empties=False,
+                max_depth=0) -> str:
+    _serializer.skip_keys = skip_keys
+    _serializer.skip_values = skip_values
+    _serializer.skip_private = skip_private
+    _serializer.skip_nones = skip_nones
+    _serializer.skip_empties = skip_empties
+    _serializer.max_depth = max_depth
+    return _serializer.serialize(anything)

batutils/tpu/comparison/__init__.py

@@ -0,0 +1 @@
+from ._mixin import *

batutils/tpu/comparison/_mixin.py

@@ -0,0 +1,30 @@
+__all__ = [
+    'ComparableMixin',
+]
+
+
+class ComparableMixin(object):
+    """Mixin class for types that should be comparable.
+    Subclasses must implement `__lt__`.
+    Other comparison functions can be overridden if desired.
+    """
+    def __new__(cls, *args):
+        obj = object.__new__(cls)
+        if not hasattr(obj, '__lt__'):
+            raise NotImplementedError('__lt__ must be overridden.')
+        return obj
+
+    def __eq__(self, other):
+        return not self < other and not other < self
+
+    def __ne__(self, other):
+        return self < other or other < self
+
+    def __gt__(self, other):
+        return other < self
+
+    def __ge__(self, other):
+        return not self < other
+
+    def __le__(self, other):
+        return not other < self

batutils/tpu/insp/__init__.py

@@ -0,0 +1,2 @@
+from ._insp_old import *
+from ._typecheck import *