def test_should_return_get_bindings_from_source(mocker: MagicMock) -> None:
bindings = [{
'source': 'one-s',
'destination': 'one-d',
'routing_key': 'one-r',
'destination_type': 'queue',
'arguments': None
}, {
'source': 'two-s',
'destination': 'two-d',
'routing_key': 'two-r',
'destination_type': 'exchange',
'arguments': None
}]
response = mock_response(bindings)
patch = mocker.patch('requests.get', return_value=response)
result = map(
lambda i: i.to_dict(),
get_bindings_from_source(broker=fake_broker(),
vhost='EA',
source='test'))
assert_that(result).is_equal_to(bindings)
patch.assert_called_with(
url='https://fake-broker/api/exchanges/EA/test/bindings/source',
auth=('guest', 'guest'))
def get_vhosts(broker: dict) -> dict:
url = 'https://{}/api/vhosts'.format(broker['host'])
response: requests.Response = requests.get(url=url,
auth=(broker['user'],
broker['passwd']))
if not response.ok:
# noinspection PyTypeChecker
raise ServerErrorException(str(response.status_code), url=url)
return map(lambda i: i['name'], response.json())
def test_should_return_empty_list_when_get_bindings_but_no_bindings(
mocker: MagicMock) -> None:
bindings: List[dict] = []
response = mock_response(bindings)
patch = mocker.patch('requests.get', return_value=response)
result = map(lambda i: i.to_dict(),
get_bindings(broker=fake_broker(), vhost='EA'))
assert_that(result).is_equal_to([])
patch.assert_called_with(url='https://fake-broker/api/bindings/EA',
auth=('guest', 'guest'))
def wrapper(x):
base_opts = pipe(prop('figures'), prop(fig_name),
A.andop(r.map(prop, ('x_range', 'y_range'))),
c.zip(('x_range', 'y_range')), dict)(x.value)
fig = bkp.figure(**base_opts, **opts)
df = pd.DataFrame({
'figures': [fig],
'circles': [None]
},
index=[fig.name])
return df
# print one vote
# print data[0]
# list the category types
# R.pipe(
# R.map(R.prop('category')),
# hist_list
# )(data)
# filter data for only the amendments
amendments = R.filter(R.propEq('category', 'amendment'), data)
# all the passing amendments and the ratio of yes votes
passing = R.pipe(
R.filter(amendment_passed),
R.map(yes_ratio)
)(amendments)
# all the failing amendments and the ratio of yes votes
failing = R.pipe(
R.filter(amendment_failed),
R.map(yes_ratio)
)(amendments)
# the percent of nonconsenting voters
dissatisfied_passing = R.map(lambda x: 1 - x, passing)
dissatisfied = R.mean(dissatisfied_passing + failing)
# plot a histogram
bins = 200
bins = np.linspace(0.0, 1.0, bins)
def get_bindings(broker: dict, vhost: str) -> List[Binding]:
url = 'https://{}/api/bindings/{}'.format(broker['host'], vhost)
response = requests.get(url=url, auth=(broker['user'], broker['passwd']))
handle_rest_response(response=response, url=url)
return map(lambda i: Binding(i), response.json())
#!/usr/bin/env python
from bs4 import BeautifulSoup
# from urllib.request import urlopen
import re
import sys
from pyramda import map, inc
html_page = ""
for line in sys.stdin:
html_page += line
# html_page = urlopen("https://files.d3engineering.com/stable")
soup = BeautifulSoup(html_page, features="lxml")
links = map(lambda x: x.get('href'), soup.find_all('a'))
_, *links = links
links = filter(lambda x: x.endswith('/'), links)
*links, tail = list(links)
print(tail[:-1])
def get_users(broker: dict) -> dict:
url = 'https://{}/api/users'.format(broker['host'])
response = requests.get(url=url, auth=(broker['user'], broker['passwd']))
handle_rest_response(response=response, url=url)
return map(lambda i: i['name'], response.json())
def invoker(x):
result = r.map(self.decorator(fn), self._fn(x))
return result
def map(self,fn):
return type(self)( tuple(r.map(curry(fn),self.value)) )
@r.curry
def node_transformer(fn,data):
print(f'f: {data!r}')
# if not isinstance(data,Traversable) and not isinstance(data,Applicative):
# return fn(data)
if isinstance(data,Traversable):
return fn(data)
return data
a = Applicative.of(10)
b = Applicative.of(r.add)
rand = lambda x: Applicative.of(random.random()*x)
t = Traversable( tuple(r.map(Applicative.of,(1,2,3)) ))
to = t.traverse(fmap(r.add(9)))
aps = Applicative.of( Applicative.of( Traversable( (10,11) )) )
ts = Traversable( ( Traversable.of(9) , 8, Traversable.of(Traversable.of(1))) )
ts2 = Traversable( ( Traversable( (9,Traversable.of(10)) ) , Traversable.of(8), Traversable.of(Traversable.of(1))) )
ts3 = Applicative((
Applicative.of( (9,) ) ,
Applicative.of( (8,) ),
Applicative.of(
( Applicative.of( (1,) ), )
)))
@r.curry
def freduce(fn,start_value,this):
def _printexpr_operator(node, ctx):
thint = get("thint", ctx)
arity = len(node.operands)
if arity == 1:
r1 = _printexpr(node.operands[0],
merge(ctx, dict(lhs=False,
thint=_THint.logic,
lhint=None)))
if node.op == "-":
expr = "(-{})".format(_signed(r1))
if thint == _THint.un_signed:
return expr
elif thint == _THint.integer:
return _to_integer(expr)
elif thint == _THint.logic:
return _std_logic_vector(expr)
else:
return expr
else:
expr = "{} {}".format(_get_op(node), r1)
if thint == _THint.un_signed:
return _unsigned(expr)
elif thint == _THint.integer:
return _fn_call("to_integer", _unsigned(expr))
elif thint == _THint.boolean:
return _fn_call("\\??\\", expr)
else:
return "({})".format(expr)
elif arity == 2:
if _is_bitwise_op(node):
r1, r2 = pipe(
[node, ctx],
juxt([
comp(attrgetter("operands"), first),
comp(repeat, flip(merge, dict(lhs=False,
thint=_THint.logic,
lhint=None)), second),
]), R.apply(zip), map(R.apply(_printexpr)))
expr = pipe([r1, _get_op(node), r2], " ".join)
if thint == _THint.un_signed:
return _unsigned(expr)
elif thint == _THint.integer:
return _fn_call("to_integer", expr)
else:
return expr
elif _is_comp_op(node):
if pipe(node.operands, R.all_satisfy(comp(R.equals(1), len))):
r1, r2 = pipe(
[node, ctx],
juxt([
comp(attrgetter("operands"), first),
comp(repeat, flip(merge, dict(lhs=False,
thint=_THint.logic,
lhint=None)), second),
]), R.apply(zip), R.map(R.apply(_printexpr)))
else:
r1, r2 = pipe(
[node, ctx],
juxt([
comp(attrgetter("operands"), first),
comp(repeat, second)]), R.apply(zip),
map(juxt([
first,
comp(
R.apply(merge),
juxt([
second,
R.always(dict(lhs=False, lhint=None)),
R.if_else(
comp(R.isinstance(Constant), first),
R.always(dict(thint=_THint.integer)),
R.always(dict(thint=_THint.un_signed)))
]))])),
map(R.apply(_printexpr)))
if thint == _THint.logic:
return _fn_call(pipe(node, _get_op, "\\?{}\\".format), r1, r2)
else:
return pipe([r1, _get_op(node), r2], " ".join)
elif _is_shift_op(node):
r1, r2 = pipe(
[node, ctx],
juxt([
comp(attrgetter("operands"), first),
comp(repeat, second)]), R.apply(zip),
map(juxt([
first,
comp(
R.apply(merge),
juxt([
second,
R.always(dict(lhs=False, lhint=None)),
R.if_else(
comp(R.isinstance(Constant), first),
R.always(dict(thint=_THint.integer)),
R.always(dict(thint=_THint.un_signed)))
]))])),
map(R.apply(_printexpr)))
expr = _fn_call(_shift_op[node.op], r1, r2)
if thint == _THint.integer:
return _fn_call("to_integer", expr)
elif thint == _THint.logic:
return _std_logic_vector(expr)
else:
return expr
elif _is_arith_op(node):
r1, r2 = pipe(
node.operands,
map(lambda x:
_printexpr(x,
merge(ctx,
dict(lhs=False,
thint=_THint.integer
if R.isinstance(Constant, x)
else _THint.un_signed,
lhint=None)))))
expr = pipe([r1, _arith_op_map[node.op], r2], " ".join)
if thint == _THint.integer:
return _fn_call("to_integer", expr)
elif thint == _THint.logic:
return _std_logic_vector(expr)
else:
return expr
raise TypeError("unkown operator: {}, arity: {}".format(node, arity))
def _printexpr_operator(node, ctx):
thint = get("thint", ctx)
arity = len(node.operands)
if arity == 1:
r1 = _printexpr(
node.operands[0],
merge(ctx, dict(lhs=False, thint=_THint.logic, lhint=None)))
if node.op == "-":
expr = "(-{})".format(_signed(r1))
if thint == _THint.un_signed:
return expr
elif thint == _THint.integer:
return _to_integer(expr)
elif thint == _THint.logic:
return _std_logic_vector(expr)
else:
return expr
else:
expr = "{} {}".format(_get_op(node), r1)
if thint == _THint.un_signed:
return _unsigned(expr)
elif thint == _THint.integer:
return _fn_call("to_integer", _unsigned(expr))
elif thint == _THint.boolean:
return _fn_call("\\??\\", expr)
else:
return "({})".format(expr)
elif arity == 2:
if _is_bitwise_op(node):
r1, r2 = pipe([node, ctx],
juxt([
comp(attrgetter("operands"), first),
comp(
repeat,
flip(
merge,
dict(lhs=False,
thint=_THint.logic,
lhint=None)), second),
]), R.apply(zip), map(R.apply(_printexpr)))
expr = pipe([r1, _get_op(node), r2], " ".join)
if thint == _THint.un_signed:
return _unsigned(expr)
elif thint == _THint.integer:
return _fn_call("to_integer", expr)
else:
return expr
elif _is_comp_op(node):
if pipe(node.operands, R.all_satisfy(comp(R.equals(1), len))):
r1, r2 = pipe([node, ctx],
juxt([
comp(attrgetter("operands"), first),
comp(
repeat,
flip(
merge,
dict(lhs=False,
thint=_THint.logic,
lhint=None)), second),
]), R.apply(zip), R.map(R.apply(_printexpr)))
else:
r1, r2 = pipe(
[node, ctx],
juxt([
comp(attrgetter("operands"), first),
comp(repeat, second)
]), R.apply(zip),
map(
juxt([
first,
comp(
R.apply(merge),
juxt([
second,
R.always(dict(lhs=False, lhint=None)),
R.if_else(
comp(R.isinstance(Constant), first),
R.always(dict(thint=_THint.integer)),
R.always(dict(thint=_THint.un_signed)))
]))
])), map(R.apply(_printexpr)))
if thint == _THint.logic:
return _fn_call(pipe(node, _get_op, "\\?{}\\".format), r1, r2)
else:
return pipe([r1, _get_op(node), r2], " ".join)
elif _is_shift_op(node):
r1, r2 = pipe(
[node, ctx],
juxt([
comp(attrgetter("operands"), first),
comp(repeat, second)
]), R.apply(zip),
map(
juxt([
first,
comp(
R.apply(merge),
juxt([
second,
R.always(dict(lhs=False, lhint=None)),
R.if_else(
comp(R.isinstance(Constant), first),
R.always(dict(thint=_THint.integer)),
R.always(dict(thint=_THint.un_signed)))
]))
])), map(R.apply(_printexpr)))
expr = _fn_call(_shift_op[node.op], r1, r2)
if thint == _THint.integer:
return _fn_call("to_integer", expr)
elif thint == _THint.logic:
return _std_logic_vector(expr)
else:
return expr
elif _is_arith_op(node):
r1, r2 = pipe(
node.operands,
map(lambda x: _printexpr(
x,
merge(
ctx,
dict(lhs=False,
thint=_THint.integer if R.isinstance(Constant, x)
else _THint.un_signed,
lhint=None)))))
expr = pipe([r1, _arith_op_map[node.op], r2], " ".join)
if thint == _THint.integer:
return _fn_call("to_integer", expr)
elif thint == _THint.logic:
return _std_logic_vector(expr)
else:
return expr
raise TypeError("unkown operator: {}, arity: {}".format(node, arity))