from typing import *
def flatten_subset(d: dict, keys = Iterable[str], *, sep: str = ".") -> Iterable:
  def get_nested_elem(key: str):
    v = d
    for k in key.split(sep):
        v = v[k]
    return v
    
  for key in keys:
    yield get_nested_elem(key)


if __name__ == '__main__': # test
  d = {"foo": [1, 2], "bar": {'0': 0, '1': 1}, "baz": 3}
  keys = ("foo", "bar.0")
  want = [[1, 2], 0]
  got = list(flatten_subset(d, keys))
  assert got == want

Eela6 fucked around with this message at 23:45 on Dec 14, 2017

def ordering_mixin(*args: str, default: Any = None):
    """order_by returns a mixin class which provides ordering operators. 
    These operators order lexigraphically by the attributes with the names in 'args'. 
    ordering_mixin will only compare two classes with the same ordering attrributes; that is,
    classes created with equivalent ordering_mixins"""

    if default is not None:
        def attrs(obj: Any) -> Iterator[Any]: 
            return (getattr(obj, arg, default) for arg in args)
    else:
        def attrs(obj: Any) -> Iterator[Any]:
            return (getattr(obj, arg) for arg in args)

    
    @total_ordering
    class OrderedMixin:
        _ordered_mixin_args = tuple(args)
        def __lt__(self, other: Any):
            if not hasattr(other, '_ordered_mixin_args') or other._ordered_mixin_args != self._ordered_mixin_args:
                return NotImplemented
            for a, b in zip(attrs(self), attrs(other)):
                if a < b:
                    return True
                elif b < a:
                    return False
            return False

        def __eq__(self, other: Any):
            if not hasattr(other, '_ordered_mixin_args') or other._ordered_mixin_args != self._ordered_mixin_args:
                return NotImplemented
            return all(a == b for a, b in zip(attrs(self), attrs(other)))
        

    return OrderedMixin

if __name__ == '__main__':
    class TestClass(ordering_mixin('a', 'b')):
       def __init__(self, a, b, c, d):
            self.a, self.b, self.c, self.d = a, b, c, d


    foo = TestClass(2, 3, 0, 0)
    bar = TestClass(2, 4, 0, 0)
    baz = TestClass(1, 3, 0, 0)

    class TestClass2(ordering_mixin('c', 'd')):
        def __init__(self, a, b, c, d):
           self.a, self.b, self.c, self.d = a, b, c, d

    assert foo < bar
    assert bar > baz
    assert foo == foo
    poo = TestClass2(2, 3, 0, 0)
    try:
        foo < poo
        raise AssertionError('should have raised a typeerror')
    except TypeError as e:
        pass

Eela6 fucked around with this message at 21:03 on Dec 19, 2017

a = {'foo', 'bar'}
b = {'bar', 'baz'}
assert  a|b ==  {'foo', 'bar', 'baz'} # union
assert a & b == {'bar'} # intersection 
assert a ^ b == {'foo', 'baz'} # xor
assert a-b == {'foo'} #difference

assert {'foo'} < {'foo', 'bar'} # proper subset
assert not {'foo'} < {'foo'} # a set is not a proper subset of itself
assert {'foo'} <= {'foo'} # improper subset

Eela6 fucked around with this message at 22:22 on Dec 20, 2017

from typing import *

def old_lookup(d1: Dict[int, List[str]], d2: Dict[int, List[str]]) -> List[str]:
    some_list = []

    for k, v in d1.items():
        for x in range(len(d1)):
            for y in range(len(d2)):
                some_list.append(str(d1[k][x]) + str(d2[k][y]))
    return some_list



def new_lookup(d1: Dict[int, List[str]], d2: Dict[int, List[str]]) -> Iterable[str]:
    for k in d1:
        v1, v2 = d1[k], d2[k]
        for x in v1:
            for y in v2:
                yield str(x)+str(y)
            

if __name__ == '__main__':
    d1 = {n: [f"d1_{n}_{m}" for m in range(3)] for n in range(3)}
    d2 = {n: [f'd2_{n}_{m}' for m in range(3)] for n in range(3)}
    want = old_lookup(d1, d2)
    got = list(new_lookup(d1, d2))
    
    assert want == got

def new_lookup(d1: Dict[int, List[str]], d2: Dict[int, List[str]]) -> Iterable[str]:
    for k in d1:
        v1, v2 = d1[k], d2[k]
        return (str(x)+str(y) for x in v1 for y in v2)

Eela6 fucked around with this message at 20:55 on Dec 21, 2017

Eela6 fucked around with this message at 21:05 on Jan 17, 2018

Eela6 fucked around with this message at 22:47 on Jan 17, 2018

from typing import *
def get_distance_groups(a: List[int], tol:int) -> Iterator[List[int]]:
    start, prev = 0, a[0]
    for i, n in enumerate(a):
        if abs(prev-n) > tol: # important! n could be negative!
            yield a[start:i]
            start = i
        prev = n
    if start < len(a)-1:
        yield a[start:]

groups = get_distance_groups(a= [0, 14, 18, 20, 36, 41, 62, 70, 72], tol=5)
print([x for x in groups if len(x) > 1])

Eela6 fucked around with this message at 00:36 on Feb 9, 2018

for i, c in enumerate(['g','o','o','n']):
    print(f'({i}, {c})', end="\t")

(0, g)  (1, o)  (2, o)  (3, n)

def insertion_sort(unsorted): #use a more descriptive name for variable argument rather than aliasing 'list'
    def insert(sorted, new_value):
        # no need for bounds check; this loop is a no-op if len(a) == 0
        for j, v in enumerate(a):
            if new_value <= v:
                sorted.insert(j, new_value)
                return a 
       
        a.append(new_value) # v is bigger than every element in a (this also covers the empty list)
        return a

    sorted = []
    for v in unsorted:
        sorted = insert(sorted, v)
    return sorted

Eela6 fucked around with this message at 05:46 on Mar 18, 2018