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

Shadow0 fucked around with this message at 07:02 on Dec 17, 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

flippity flop shitkabob the wrong whistler and so are you, come get some no dad is dad as you zoom zam everyone is prettty hotttt my cousin steals eggnog umbrella yeah now you see begrudingly huge piss orange monkey congratulate synergie ghetto lambda extraverti nyctalope donkey dong county fattest man on the moon what what yeah no say say i love velo poupoupidou zoop 1 2 3 tell my friends I love me

unpacked robinhood fucked around with this message at 12:39 on Dec 20, 2017

Dominoes fucked around with this message at 20:09 on Dec 20, 2017

In [1]: {'a', 'b', 'c', 'b'} == {'c', 'a', 'b'}
Out[1]: True

Lysidas fucked around with this message at 20:14 on Dec 20, 2017

Sockser fucked around with this message at 20:36 on Dec 20, 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

from itertools import product, chain

combos = (product(d1[server], d2[server]) for server in d1.keys())
as_strings = ["".join(parts) for parts in chain.from_iterable(combos)]

baka kaba fucked around with this message at 00:09 on Dec 22, 2017