communal 0.4.5__py3-none-any.whl

communal/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.4.5"

communal/attrdict.py

@@ -0,0 +1,16 @@
+class AttrDict(dict):
+    """
+    A dictionary that allows using the dot operator to get and set keys.
+    """
+
+    def __getattr__(self, key):
+        return self[key]
+
+    def __setattr__(self, key, value):
+        self[key] = value
+
+    def __delattr__(self, key):
+        del self[key]
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}({dict.__repr__(self)})"

communal/binary.py

@@ -0,0 +1,79 @@
+import base64
+
+from communal.encoding import safe_decode, safe_encode
+from communal.functions import Pipeline
+from communal.properties import classproperty
+
+
+def int_to_bytes(x: int, endianness="little"):
+    if not isinstance(x, int):
+        x = int(x)
+    return x.to_bytes((x.bit_length() + 7) // 8, endianness)
+
+
+def int_from_bytes(x: bytes, endianness="little"):
+    return int.from_bytes(x, endianness)
+
+
+class BinaryEncoder(object):
+    @classmethod
+    def strip_padding(cls, s):
+        return s.rstrip(b"=")
+
+    @classproperty
+    def encode(cls):
+        return Pipeline(cls.encoder, cls.strip_padding)
+
+    @classmethod
+    def add_padding(cls, s):
+        return s if len(s) % cls.group_width == 0 else s.ljust(cls.group_width, b"=")
+
+    @classproperty
+    def decode(cls):
+        return Pipeline(cls.add_padding, cls.decoder)
+
+    @classmethod
+    def encode_str(cls, s: str):
+        return safe_decode(cls.encode(safe_encode(s)))
+
+    @classmethod
+    def encode_int(cls, x: int, endianness: str = "little"):
+        return safe_decode(cls.encode(int_to_bytes(x, endianness=endianness)))
+
+    @classmethod
+    def decode_str(cls, s: str):
+        return safe_decode(cls.decode(safe_encode(s)))
+
+    @classmethod
+    def decode_int(cls, s: str, endianness: str = "little"):
+        return int_from_bytes(cls.decode(safe_encode(s)), endianness=endianness)
+
+
+class Base16(BinaryEncoder):
+    bits = 16
+    group_width = 2
+    encoder = base64.b16encode
+    decoder = base64.b16decode
+
+
+class Base32(BinaryEncoder):
+    bits = 32
+    group_width = 8
+    encoder = base64.b32encode
+    decoder = base64.b32decode
+
+
+class Base64(BinaryEncoder):
+    bits = 64
+    group_width = 8
+    encoder = base64.b64encode
+    decoder = base64.b64decode
+
+
+class Base85(BinaryEncoder):
+    bits = 85
+    encoder = base64.b85encode
+    decoder = base64.b85decode
+
+    encode = encoder
+    decode = decoder

communal/casing.py

@@ -0,0 +1,23 @@
+import re
+
+camel_to_snake_re_all_caps = re.compile("([A-Z\\d]+)([A-Z][a-z])")
+camel_to_snake_re_before_word = re.compile("([a-z])([A-Z])")
+
+
+def camel_to_snake_case(name):
+    name = camel_to_snake_re_all_caps.sub("\\1_\\2", name)
+    name = camel_to_snake_re_before_word.sub("\\1_\\2", name)
+    name = name.replace("-", "_")
+    return name.lower()
+
+
+def to_camel_case(name):
+    return name.title().replace(" ", "").replace("_", "")
+
+
+def to_title_case(name):
+    """Convert all upper or all lower case names to title case, otherwise preserve casing."""
+    if name.islower() or name.isupper():
+        return name.title()
+    else:
+        return name

communal/client.py

@@ -0,0 +1,14 @@
+class ClientProxy(object):
+    client = None
+
+    def __getattr__(self, name):
+        return getattr(self.client, name)
+
+    def __getitem__(self, name):
+        return self.client[name]
+
+    def __setitem__(self, name, value):
+        self.client[name] = value
+
+    def __delitem__(self, name):
+        del self.client[name]

communal/collections.py

@@ -0,0 +1,15 @@
+from collections import OrderedDict
+from collections.abc import Hashable, Mapping
+
+
+def unique_list(values):
+    """Produces a unique list while preserving input order"""
+    return list(OrderedDict.fromkeys(values))
+
+
+def is_mapping(val):
+    return isinstance(val, Mapping)
+
+
+def is_hashable(val):
+    return isinstance(val, Hashable)

communal/dates.py

@@ -0,0 +1,26 @@
+from datetime import date, datetime
+
+from dateutil.parser import parse as _dateutil_parse
+
+
+def current_timestamp():
+    return datetime.utcnow().timestamp()
+
+
+def current_year():
+    return date.today().year
+
+
+parse_datetime = _dateutil_parse
+
+
+def parse_date(dt):
+    return _dateutil_parse(dt).date()
+
+
+def parse_datetime_ignore_tz_microseconds(d):
+    return _dateutil_parse(d, ignoretz=True)
+
+
+def parse_datetime_ignore_tz_seconds(d):
+    return _dateutil_parse(d, ignoretz=True).replace(microsecond=0)

communal/download.py

@@ -0,0 +1,36 @@
+import os
+import shutil
+
+import fsspec
+import furl
+import requests
+
+from communal.files import ensure_dir
+
+
+def save_response_content(response, destination):
+    with fsspec.open(destination, "wb") as f:
+        shutil.copyfileobj(response.raw, f)
+
+
+def download_file(url, dest, retries=3, retry_delay=5, session=requests, headers=None):
+    url = furl.furl(url)
+
+    exists = os.path.exists(dest)
+    is_dir = os.path.isdir(dest) if exists else len(os.path.splitext(dest)[1]) == 0
+
+    base_dir = dest if is_dir else os.path.dirname(dest)
+    if base_dir:
+        ensure_dir(base_dir)
+
+    dest_filename = os.path.basename(dest) if not is_dir else None
+    if not dest_filename and url.path.isfile:
+        dest_filename = url.path.segments[-1]
+        dest = os.path.join(dest, dest_filename)
+
+    with session.get(url, headers=headers, stream=True) as resp:
+        resp.raw.decode_content = True
+        resp.raise_for_status()
+        save_response_content(resp, dest)
+
+    return dest

communal/encoding.py

@@ -0,0 +1,34 @@
+def safe_decode(
+    value, encoding="utf-8", errors="strict", text_types=str, binary_types=bytes
+):
+    if isinstance(value, text_types):
+        return value
+
+    if isinstance(value, binary_types):
+        return value.decode(encoding, errors)
+    else:
+        return str(value)
+
+
+def safe_encode(
+    value,
+    encoding="utf-8",
+    from_encoding=None,
+    errors="strict",
+    text_types=str,
+    binary_types=bytes,
+):
+    if isinstance(value, text_types):
+        return value.encode(encoding, errors=errors)
+    elif isinstance(value, binary_types):
+        if hasattr(from_encoding, "lower"):
+            from_encoding = from_encoding.lower()
+        if hasattr(encoding, "lower"):
+            encoding = encoding.lower()
+
+        if value and from_encoding and encoding and encoding != from_encoding:
+            value = safe_decode(value, encoding=from_encoding, errors=errors)
+            return value.encode(encoding, errors)
+        return value
+    else:
+        return bytes(repr(value), encoding=encoding)

communal/enum.py

@@ -0,0 +1,32 @@
+import enum
+
+
+class StringEnum(str, enum.Enum):
+    def __str__(self):
+        return str(self.value)
+
+    @classmethod
+    def display_name(cls, choice):
+        return choice.name
+
+    @property
+    def display(self):
+        return self.value.replace("_", " ").title()
+
+    @classmethod
+    def choices(cls):
+        return [(choice.value, cls.display_name(choice)) for choice in cls]
+
+    @classmethod
+    def from_value(cls, value):
+        return cls(value)
+
+
+class LabeledEnum(enum.Enum):
+    label: str
+
+    def __new__(cls, value, label):
+        obj = object.__new__(cls)
+        obj._value = value
+        obj.label = label
+        return obj

communal/exceptions.py

@@ -0,0 +1,6 @@
+class ConfigurationError(Exception):
+    pass
+
+
+class DecoratorIncompatibilityError(ConfigurationError):
+    pass

communal/files.py

@@ -0,0 +1,42 @@
+import os
+import shutil
+
+import fsspec
+
+from communal.sizes import COPY_BUFFER_SIZE
+
+
+def ensure_dir(d):
+    if not os.path.exists(d):
+        os.makedirs(d)
+
+
+def copy_file(filename, dest, buffer_size=COPY_BUFFER_SIZE):
+    dest_kwargs = {}
+    if dest.endswith(".gz") and not filename.endswith(".gz"):
+        dest_kwargs.update(compression="gzip")
+    elif dest.endswith(".zip") and not filename.endswith(".zip"):
+        dest_kwargs.update(compression="zip")
+
+    with fsspec.open(dest, "wb", **dest_kwargs) as df:
+        with fsspec.open(filename, "rb") as sf:
+            shutil.copyfileobj(sf, df)
+    return dest
+
+
+def remove_file(filename):
+    os.unlink(filename)
+
+
+class cd:
+    """Context manager for changing the current working directory"""
+
+    def __init__(self, path):
+        self.path = path
+
+    def __enter__(self):
+        self.saved_path = os.getcwd()
+        os.chdir(self.path)
+
+    def __exit__(self, etype, value, traceback):
+        os.chdir(self.saved_path)

communal/floats.py

@@ -0,0 +1,5 @@
+import math
+
+FLOAT_EPSILON = 1e-09
+
+float_equals = math.isclose

communal/functions.py

@@ -0,0 +1,349 @@
+import functools
+import inspect
+import itertools
+import operator
+import re
+from collections import deque
+
+from communal.exceptions import DecoratorIncompatibilityError
+from communal.iterables import iterify
+from communal.nulls import DoesNotExist
+
+
+def nop(obj):
+    return obj
+
+
+def equal_to(other):
+    return functools.partial(operator.eq, other)
+
+
+def not_equal_to(other):
+    return functools.partial(operator.ne, other)
+
+
+def argmin(a):
+    return min(range(len(a)), key=a.__getitem__)
+
+
+def argmax(a):
+    return max(range(len(a)), key=a.__getitem__)
+
+
+is_none = functools.partial(operator.is_, None)
+not_none = functools.partial(operator.is_not, None)
+
+
+def if_none(default):
+    def value(v):
+        return v if v is not None else default
+
+    return value
+
+
+def stop_on_input_values(*vals, default=None):
+    if not vals:
+        vals = (None,)
+
+    def deco(f):
+        @functools.wraps(f)
+        def func(v):
+            return f(v) if v not in vals else default
+
+        return func
+
+    if len(vals) == 1 and callable(vals[0]):
+        f = vals[0]
+        vals = (None,)
+        return deco(f)
+    return deco
+
+
+call_if_not_null = stop_on_input_values(None)
+
+
+def stop_on_conditions(*conditions, default=None):
+    def deco(f):
+        @functools.wraps(f)
+        def func(v):
+            all_conditions_met = all((c(v) for c in conditions))
+            return f(v) if all_conditions_met else default
+
+        return func
+
+    return deco
+
+
+true_values = {"TRUE", "T", "Y", "YES", "ON", "1"}
+false_values = {"FALSE", "F", "N", "NO", "OFF", "0"}
+
+
+def str_to_bool(value: str):
+    value = (value or "").upper()
+    if value in true_values:
+        return True
+    elif value in false_values:
+        return False
+    else:
+        return None
+
+
+def attr_get(*keys: str, default=None):
+    def get_attrs(o):
+        return [getattr(o, k, default) for k in keys]
+
+    if len(keys) == 1:
+        key = keys[0]
+
+    def get_attr(o):
+        return getattr(o, key, default)
+
+    return get_attrs if len(keys) > 1 else get_attr
+
+
+def item_get(*keys: str, default=None):
+    def get_keys(d):
+        return [d.get(k, default) for k in keys]
+
+    if len(keys) == 1:
+        key = keys[0]
+
+    def get_key(d):
+        return d.get(key, default)
+
+    return get_keys if len(keys) > 1 else get_key
+
+
+def attr_or_key_getter(key, default=DoesNotExist):
+    def with_obj(obj):
+        val = getattr(obj, key, DoesNotExist)
+        if val is DoesNotExist:
+            try:
+                val = obj[key]
+                obj = val
+            except (IndexError, TypeError):
+                val = default
+        else:
+            obj = val
+        return val
+
+    return with_obj
+
+
+def has_all_attrs(*attrs: str):
+    def attrs_exist(o):
+        return all((hasattr(o, a) for a in attrs))
+
+    if len(attrs) == 1:
+        attr = attrs[0]
+
+    def attr_exists(o):
+        return hasattr(o, attr)
+
+    return attrs_exist if len(attrs) > 1 else attr_exists
+
+
+def all_attrs_not_none(*attrs: str):
+    def attrs_not_none(o):
+        return all((getattr(o, a, None) is not None for a in attrs))
+
+    if len(attrs) == 1:
+        attr = attrs[0]
+
+    def attr_not_none(o):
+        return getattr(o, attr, None) is not None
+
+    return attrs_not_none if len(attrs) > 1 else attr_not_none
+
+
+def has_all_keys(*keys: str):
+    def keys_exist(d):
+        return all((k in d for k in keys))
+
+    if len(keys) == 1:
+        key = keys[0]
+
+    def key_exists(d):
+        return key in d
+
+    return keys_exist if len(keys) > 1 else key_exists
+
+
+def all_keys_not_none(*keys: str):
+    def keys_not_none(d):
+        return all((d.get(k, None) is not None for k in keys))
+
+    if len(keys) == 1:
+        key = keys[0]
+
+    def key_not_none(d):
+        return d.get(key, None) is not None
+
+    return keys_not_none if len(keys) > 1 else key_not_none
+
+
+def map_values(d: dict):
+    def mapped_value(val):
+        return d.get(val, val)
+
+    return mapped_value
+
+
+# Because partials are only specifying the first argument to a function,
+# and we're effectively specifying the righthand side up front and then
+# running the function on a bunch of inputs, we use the inverse functions
+# e.g. less_than(5) will run x < 5 for any x. To make the arguments left-to-right,
+# we end up calling the equivalent operator.gt(5, x), or is 5 > x
+
+
+def less_than(other):
+    return functools.partial(operator.gt, other)
+
+
+def greater_than(other):
+    return functools.partial(operator.lt, other)
+
+
+def less_than_or_equal_to(other):
+    return functools.partial(operator.ge, other)
+
+
+def greater_than_or_equal_to(other):
+    return functools.partial(operator.le, other)
+
+
+def regex_sub(pattern, repl):
+    pattern = re.compile(pattern)
+    return functools.partial(pattern.sub, repl)
+
+
+class Pipeline(object):
+    def __init__(self, *functions):
+        self.functions = functions
+
+    def __repr__(self):
+        return "Pipeline: [{}]".format(
+            ", ".join((str(func) for func in self.functions))
+        )
+
+    def __call__(self, val):
+        for f in self.functions:
+            val = f(val)
+        return val
+
+
+class FunctionMap(object):
+    def __init__(self, *functions, use_tuple=True):
+        self.functions = functions
+        self.use_tuple = use_tuple
+
+    def __repr__(self):
+        return f'{self.__class__.__name__}: [{", ".join((str(func) for func in self.functions))}]'
+
+    def __call__(self, *args, **kw):
+        val = [func(*args, **kw) for func in self.functions]
+        if self.use_tuple:
+            return tuple(val)
+        else:
+            return val
+
+
+class FunctionZipMap(FunctionMap):
+    def __call__(self, vals, **kw):
+        val = [func(arg, **kw) for func, arg in zip(self.functions, vals)]
+
+        if self.use_tuple:
+            return tuple(val)
+        else:
+            return val
+
+
+class FunctionStarMap(object):
+    def __init__(self, function, use_tuple=True):
+        self.function = function
+        self.use_tuple = use_tuple
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}: {self.function}"
+
+    def __call__(self, *args, **kw):
+        val = list(
+            itertools.chain(*itertools.starmap(self.function, itertools.chain(*args)))
+        )
+        if self.use_tuple:
+            return tuple(val)
+        else:
+            return val
+
+        return ()
+
+
+class VectorFunction(object):
+    def __init__(self, function):
+        self.function = function
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}: {self.function}"
+
+    def __call__(self, values):
+        return list(map(self.function, values))
+
+
+class ChainedFunction(object):
+    def __init__(self, function):
+        self.function = function
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}: {self.function}"
+
+    def __call__(self, values):
+        return list(itertools.chain(*(map(self.function, iterify(v)) for v in values)))
+
+
+class hybridmethod(object):
+    def __init__(self, func):
+        self.func = func
+
+    def __get__(self, instance, owner):
+        self_or_cls = owner if instance is None else instance
+
+        @functools.wraps(self.func)
+        def call_hybrid(*args, **kwargs):
+            return self.func(self_or_cls, *args, **kwargs)
+
+        return call_hybrid
+
+
+def get_innermost_argspec(method):
+    """When passed a method/function, drill through all layers of decorators to get the inner argspec."""
+
+    orig_method = method
+    q = deque([orig_method])
+    while q:
+        method = q.popleft()
+        if hasattr(method, "__func__"):
+            method = method.__func__
+        elif hasattr(method, "func"):
+            method = method.func
+
+        argspec = inspect.getfullargspec(method)
+        args = argspec.args
+
+        if args and args[0] in ("self", "cls"):
+            return argspec
+        if not hasattr(method, "__closure__") or method.__closure__ is None:
+            raise DecoratorIncompatibilityError(
+                "Decorator has no closure: {}".format(method)
+            )
+
+        closure = method.__closure__
+
+        for cell in closure:
+            inner_method = cell.cell_contents
+            if inner_method is method:
+                continue
+            if not inspect.isfunction(inner_method) and not inspect.ismethod(
+                inner_method
+            ):
+                continue
+            q.append(inner_method)