def test_caching_conversion(): class CustomException(Exception): pass def f(number): if not f.first_time: raise CustomException f.first_time = False return number f.first_time = True conv = (c.call_func(f, c.this()).pipe( c.if_(c.this(), c.this() + 1, c.this() + 2)).gen_converter()) assert conv(0) == 2 with pytest.raises(CustomException): assert conv(0) == 2 f.first_time = True assert conv(1) == 2 with pytest.raises(CustomException): c.call_func(f, c.this()).pipe( c.if_(c.this(), c.this() + 1, c.this() + 2, no_input_caching=True)).execute(0)
def test_complex_labeling(): conv1 = (c.this().add_label("input").pipe( c.filter(c.this() % 3 == 0), label_input={ "input_type": c.call_func(type, c.this()) }, ).pipe( c.list_comp(c.this().as_type(str)), label_output={ "list_length": c.call_func(len, c.this()), "separator": c.if_(c.label("list_length") > 10, ",", ";"), }, ).pipe({ "result": c.label("separator").call_method("join", c.this()), "input_type": c.label("input_type"), "input_data": c.label("input"), }).gen_converter(debug=False)) assert conv1(range(30)) == { "result": "0;3;6;9;12;15;18;21;24;27", "input_type": range, "input_data": range(0, 30), } assert conv1(range(40)) == { "result": "0,3,6,9,12,15,18,21,24,27,30,33,36,39", "input_type": range, "input_data": range(0, 40), }
def test_nested_group_by(): data = [ [0, [1, 2, 3]], [0, [4, 5, 6]], [1, [2, 3, 4]], ] assert c.group_by(c.item(0)).aggregate( ( c.item(0), c.ReduceFuncs.Sum( c.item(1).pipe(c.aggregate(c.ReduceFuncs.Sum(c.this()))) ), ) ).execute(data, debug=False) == [ (0, 21), (1, 9), ] agg_conv = c.aggregate(c.ReduceFuncs.Sum(c.this())) assert c.group_by(c.item(0)).aggregate( ( c.item(0), c.if_(c.item(1), c.item(1), c.item(1),).pipe( c.if_(c.this(), c.this(), c.this(),).pipe( c.ReduceFuncs.Sum( c.if_( c.this(), c.this(), c.this(), ) .pipe((agg_conv, agg_conv)) .pipe(c.item(1)) ).pipe( c.if_( c.this(), c.this(), c.this(), ) ), ) ), ) ).execute(data, debug=True) == [ (0, 21), (1, 9), ]
def test_pipes(): assert c.list_comp(c.inline_expr("{0} ** 2").pass_args(c.this)).pipe( c.call_func(sum, c.this)).pipe( c.call_func( lambda x, a: x + a, c.this, c.naive({ "abc": 10 }).item(c.input_arg("key_name")), )).pipe([c.this, c.this]).execute([1, 2, 3], key_name="abc", debug=False) == [ 24, 24, ] assert c.item(0).pipe(datetime.strptime, "%Y-%m-%d").pipe( c.call_func(lambda dt: dt.date(), c.this)).execute(["2019-01-01"], debug=False) == date(2019, 1, 1) assert c.item(0).pipe(datetime.strptime, "%Y-%m-%d").pipe( c.this.call_method("date")).execute(["2019-01-01"], debug=False) == date(2019, 1, 1) conv = c.dict_comp( c.item("name"), c.item("transactions").pipe( c.list_comp({ "id": c.item(0).as_type(str), "amount": c.item(1).pipe(c.if_(c.this, c.this.as_type(Decimal), None)), })), ).gen_converter(debug=False) assert conv([{ "name": "test", "transactions": [(0, 0), (1, 10)] }]) == { "test": [ { "id": "0", "amount": None }, { "id": "1", "amount": Decimal("10") }, ] } assert c.this.pipe(lambda it: it).filter( c.this).sort().as_type(list).execute((2, 1, 0)) == [1, 2]
def test_labels(): conv1 = c.if_( 1, c.input_arg("y").item("abc").add_label("abc").pipe( c.input_arg("x").pipe( c.inline_expr("{cde} + 10").pass_args( cde=c.this().item("cde")))).pipe( c.inline_expr("{this} + {abc}").pass_args( this=c.this(), abc=c.label("abc"))), 2, ).gen_converter(debug=False) assert conv1(data_=1, x={"cde": 2}, y={"abc": 3}) == 15 list(c.generator_comp(c.this().add_label("a")).execute([1, 2])) c.list_comp(c.this().add_label("a")).execute([1, 2])
def test_namespaces(): with pytest.raises(ValueError): LazyEscapedString("abc").execute([1]) with pytest.raises(ValueError): Namespace(LazyEscapedString("abc"), name_to_code={ "abc": None }).execute([1]) assert (Namespace(LazyEscapedString("abc"), name_to_code={ "abc": True }).execute(1) == 1) assert (Namespace( c.input_arg("abc") + LazyEscapedString("abc"), name_to_code={ "abc": "abc" }, ).execute(0.1, abc=2) == 4) assert Namespace(c.item(1), {}).execute([0, 10]) == 10 assert (Namespace( Namespace( Namespace(LazyEscapedString("abc"), name_to_code={"abc": True }) # 1 + LazyEscapedString("abc") # 10 + LazyEscapedString("foo") # 1000 + c.item() * 0.1, # 0.1, name_to_code={"foo": "arg_foo2"}, ), name_to_code={ "abc": "arg_abc", "foo": "arg_foo" }, )).gen_converter( debug=False, signature="data_, arg_abc=10, arg_foo=100, arg_foo2=1000")(1) == 1011.1 assert (Namespace( c.call_func(list, (1, )).pipe( c.if_( c.this, c.this * LazyEscapedString("number"), c.this, )), { "number": "3" }, ).execute(None) == [1, 1, 1])
def test_if(): conv1 = c.if_(True, c.this() * 2, c.this() - 1000).gen_converter(debug=False) assert conv1(0) == -1000 assert conv1(10) == 20 conv2 = c.list_comp(c.if_(c.this() % 2 == 0, c.this() * 10, c.this() * 100)).gen_converter(debug=False) conv3 = c.list_comp( c.if_( c.this() % 2 == 0, c.this() * 10, c.this() * 100, no_input_caching=True, )).gen_converter(debug=False) assert conv2([1, 2, 3, 4]) == [100, 20, 300, 40] assert conv3([1, 2, 3, 4]) == [100, 20, 300, 40] conv4 = c.list_comp((c.this() - 5).pipe( c.if_(c.this() % 2 == 0, c.this() * 10, c.this() * 100))).gen_converter(debug=False) assert conv4([1, 2, 3, 4]) == [-40, -300, -20, -100] conv5 = c.if_().gen_converter(debug=False) assert conv5(0) == 0 and conv5(1) == 1 conv6 = c.list_comp( c.if_(c.this(), None, c.this(), no_input_caching=True)).gen_converter(debug=False) assert conv6([1, False, 2, None, 3, 0]) == [ None, False, None, None, None, 0, ] assert PipeConversion.input_is_simple("'abc'") assert PipeConversion.input_is_simple("0") assert PipeConversion.input_is_simple("None") assert PipeConversion.input_is_simple("True") assert PipeConversion.input_is_simple("False") assert PipeConversion.input_is_simple("a[1]") assert PipeConversion.input_is_simple("a['1']") assert PipeConversion.input_is_simple("a[1][2]") assert not PipeConversion.input_is_simple("a[1][2][3]") assert not PipeConversion.input_is_simple("1 + 1") assert not PipeConversion.input_is_simple("x.a") assert not PipeConversion.input_is_simple("x()")
def test_reducer_inlining(dict_series): def f(): f.number_of_calls += 1 if f.number_of_calls > f.max_number_of_calls: raise Exception return [] f.max_number_of_calls = 1 f.number_of_calls = 0 converter = c.aggregate( c.ReduceFuncs.Array(c.item("name"), default=f, where=c.item("value") < 0).pipe( c.if_( if_true=c.this(), if_false=c.this(), ))).gen_converter(debug=False) assert converter(dict_series) == []
def test_pipe_conversion(): from convtools import conversion as c from convtools.base import PipeConversion assert PipeConversion(c.naive([1, 2, 3]), c.item(1)).execute(None) == 2 assert (PipeConversion(c.item("key1"), c.item("key2")).execute({"key1": { "key2": 3 }}, debug=False) == 3) assert (c.this.pipe(c.list_comp(c.this + 1)).filter(c.this > 3).execute( [1, 2, 3, 4, 5, 6], debug=False)) == [4, 5, 6, 7] c.aggregate( c.ReduceFuncs.Array(c.item("key"), default=list).pipe( c.if_( c.call_func(any, c.generator_comp(c.this.is_(None))), c.call_func(list), c.this, ))).gen_converter(debug=False)
def test_group_by_key_edge_case(): with pytest.raises(ValueError): c.this.add_label("row").pipe(c.ReduceFuncs.Count()) with pytest.raises(ValueError): (c.this.add_label("row") + 1).pipe(c.ReduceFuncs.Count() + 1) with pytest.raises(ValueError): c.this.pipe(c.ReduceFuncs.Count(), label_input="row") data = [ (0, 1), (1, 2), ] assert c.group_by(c.item(0)).aggregate( c.if_(c.item(1), c.item(1), c.item(1)).pipe( (c.ReduceFuncs.Sum(c.this) / c.ReduceFuncs.Count(c.this)).pipe(c.this + 10))).gen_converter( debug=False)(data) == [11, 12] assert c.group_by(c.item(0)).aggregate( c.item(1).pipe( c.ReduceFuncs.Sum(c.this), label_output="count")).gen_converter(debug=False)(data) == [1, 2]
def test_group_by_key_edge_case(): with pytest.raises(ValueError): c.this().add_label("row").pipe(c.ReduceFuncs.Count()) with pytest.raises(ValueError): (c.this().add_label("row") + 1).pipe(c.ReduceFuncs.Count() + 1) with pytest.raises(ValueError): c.this().pipe(c.ReduceFuncs.Count(), label_input="row") data = [ (0, 1), (1, 2), ] # TODO: try to test nested pipe (double overwrites) # TODO: reducer + label then pipe to somewhere assert c.group_by(c.item(0)).aggregate( c.if_(c.item(1), c.item(1), c.item(1)).pipe( (c.ReduceFuncs.Sum(c.this()) / c.ReduceFuncs.Count(c.this())).pipe( c.this() + 10 ) ) ).gen_converter(debug=False)(data) == [11, 12] assert c.group_by(c.item(0)).aggregate( c.item(1).pipe(c.ReduceFuncs.Sum(c.this()), label_output="count") ).gen_converter(debug=False)(data) == [1, 2]
def test_doc__index_deserialization(): class Employee: def __init__(self, **kwargs): self.kwargs = kwargs input_data = { "objects": [ { "id": 1, "first_name": "john", "last_name": "black", "dob": None, "salary": "1,000.00", "department": "D1 ", "date": "2000-01-01", }, { "id": 2, "first_name": "bob", "last_name": "wick", "dob": "1900-01-01", "salary": "1,001.00", "department": "D3 ", "date": "2000-01-01", }, ] } # prepare a few conversions to reuse c_strip = c.this.call_method("strip") c_capitalize = c.this.call_method("capitalize") c_decimal = c.this.call_method("replace", ",", "").as_type(Decimal) c_date = c.call_func(datetime.strptime, c.this, "%Y-%m-%d").call_method("date") # reusing c_date c_optional_date = c.if_(c.this, c_date, None) first_name = c.item("first_name").pipe(c_capitalize) last_name = c.item("last_name").pipe(c_capitalize) # call "format" method of a string and pass first & last names as # parameters full_name = c("{} {}").call_method("format", first_name, last_name) conv = ( c.item("objects").pipe( c.generator_comp({ "id": c.item("id"), "first_name": first_name, "last_name": last_name, "full_name": full_name, "date_of_birth": c.item("dob").pipe(c_optional_date), "salary": c.item("salary").pipe(c_decimal), # pass a hardcoded dict and to get value by "department" # key "department_id": c.naive({ "D1": 10, "D2": 11, "D3": 12, }).item(c.item("department").pipe(c_strip)), "date": c.item("date").pipe(c_date), })).pipe( c.dict_comp( c.item("id"), # key c.apply_func( # value Employee, args=(), kwargs=c.this, ), )).gen_converter(debug=True) # to see print generated code ) result = conv(input_data) assert result[1].kwargs == { "date": date(2000, 1, 1), "date_of_birth": None, "department_id": 10, "first_name": "John", "full_name": "John Black", "id": 1, "last_name": "Black", "salary": Decimal("1000.00"), } assert result[2].kwargs == { "date": date(2000, 1, 1), "date_of_birth": date(1900, 1, 1), "department_id": 12, "first_name": "Bob", "full_name": "Bob Wick", "id": 2, "last_name": "Wick", "salary": Decimal("1001.00"), }
def test_doc__index_deserialization(): class Employee: def __init__(self, **kwargs): self.kwargs = kwargs input_data = { "objects": [ { "id": 1, "first_name": "john", "last_name": "black", "dob": None, "salary": "1,000.00", "department": "D1 ", "date": "2000-01-01", }, { "id": 2, "first_name": "bob", "last_name": "wick", "dob": "1900-01-01", "salary": "1,001.00", "department": "D3 ", "date": "2000-01-01", }, ] } # get by "department" key and then call method "strip" department = c.item("department").call_method("strip") first_name = c.item("first_name").call_method("capitalize") last_name = c.item("last_name").call_method("capitalize") # call "format" method of a string and pass first & last names as # parameters full_name = c("{} {}").call_method("format", first_name, last_name) date_of_birth = c.item("dob") # partially initialized "strptime" parse_date = c.call_func(datetime.strptime, c.this(), "%Y-%m-%d").call_method("date") conv = ( c.item("objects").pipe( c.generator_comp({ "id": c.item("id"), "first_name": first_name, "last_name": last_name, "full_name": full_name, "date_of_birth": c.if_( date_of_birth, date_of_birth.pipe(parse_date), None, ), "salary": c.call_func( Decimal, c.item("salary").call_method("replace", ",", ""), ), # pass a hardcoded dict and to get value by "department" # key "department_id": c.naive({ "D1": 10, "D2": 11, "D3": 12, }).item(department), "date": c.item("date").pipe(parse_date), })). pipe( c.dict_comp( c.item( "id"), # key # write a python code expression, format with passed parameters c.inline_expr("{employee_cls}(**{kwargs})").pass_args( employee_cls=Employee, kwargs=c.this(), ), # value )).gen_converter(debug=True)) result = conv(input_data) assert result[1].kwargs == { "date": date(2000, 1, 1), "date_of_birth": None, "department_id": 10, "first_name": "John", "full_name": "John Black", "id": 1, "last_name": "Black", "salary": Decimal("1000.00"), } assert result[2].kwargs == { "date": date(2000, 1, 1), "date_of_birth": date(1900, 1, 1), "department_id": 12, "first_name": "Bob", "full_name": "Bob Wick", "id": 2, "last_name": "Wick", "salary": Decimal("1001.00"), }
def test_nested_group_by(): data = [ [0, [1, 2, 3]], [0, [4, 5, 6]], [1, [2, 3, 4]], ] assert c.group_by(c.item(0)).aggregate(( c.item(0), c.ReduceFuncs.Sum( c.item(1).pipe(c.aggregate(c.ReduceFuncs.Sum(c.this())))), )).execute(data, debug=False) == [ (0, 21), (1, 9), ] agg_conv = c.aggregate(c.ReduceFuncs.Sum(c.this())) assert c.group_by(c.item(0)).aggregate(( c.item(0), c.if_( c.item(1), c.item(1), c.item(1), ).pipe( c.if_( c.this(), c.this(), c.this(), ).pipe( c.ReduceFuncs.Sum( c.if_( c.this(), c.this(), c.this(), ).pipe((agg_conv, agg_conv)).pipe(c.item(1))).pipe( c.if_( c.this(), c.this(), c.this(), )), )), )).execute(data, debug=False) == [ (0, 21), (1, 9), ] summer = c.aggregate(c.ReduceFuncs.Sum(c.this())) merger = c.aggregate({ "value1": c.ReduceFuncs.First(c.item("value1"), where=c("value1").in_(c.this())), "value2": c.ReduceFuncs.First(c.item("value2"), where=c("value2").in_(c.this())).pipe( c.if_(c.this(), c.this().pipe(summer))), }) converter = (c.group_by(c.item("id_")).aggregate({ "id_": c.item("id_"), "data": c.ReduceFuncs.Array(c.this()).pipe(merger), }).gen_converter(debug=False)) assert converter([ { "id_": 1, "value1": 2 }, { "id_": 2, "value1": 3 }, { "id_": 2, "value2": [1, 2, 3] }, ]) == [ { "id_": 1, "data": { "value1": 2, "value2": None } }, { "id_": 2, "data": { "value1": 3, "value2": 6 } }, ] def g(): yield 1 raise Exception assert (c.aggregate(c.ReduceFuncs.First(c.this())).execute( g(), debug=False)) == 1
def test_pipes(): assert c.list_comp(c.inline_expr("{0} ** 2").pass_args(c.this())).pipe( c.call_func(sum, c.this())).pipe( c.call_func( lambda x, a: x + a, c.this(), c.naive({ "abc": 10 }).item(c.input_arg("key_name")), )).pipe([c.this(), c.this()]).execute([1, 2, 3], key_name="abc", debug=False) == [ 24, 24, ] assert c.item(0).pipe(datetime.strptime, "%Y-%m-%d").pipe( c.call_func(lambda dt: dt.date(), c.this())).execute(["2019-01-01"], debug=False) == date(2019, 1, 1) assert c.item(0).pipe(datetime.strptime, "%Y-%m-%d").pipe( c.this().call_method("date")).execute(["2019-01-01"], debug=False) == date(2019, 1, 1) with c.OptionsCtx() as options: max_pipe_length = options.max_pipe_length = 10 with pytest.raises(c.ConversionException): conv = c.this() for i in range(max_pipe_length + 1): conv = c.this().pipe(conv) with c.OptionsCtx() as options2, pytest.raises(c.ConversionException): options2.max_pipe_length = 5 conv.clone() conv = c.dict_comp( c.item("name"), c.item("transactions").pipe( c.list_comp({ "id": c.item(0).as_type(str), "amount": c.item(1).pipe(c.if_(c.this(), c.this().as_type(Decimal), None)), })), ).gen_converter(debug=True) assert conv([{ "name": "test", "transactions": [(0, 0), (1, 10)] }]) == { "test": [ { "id": "0", "amount": None }, { "id": "1", "amount": Decimal("10") }, ] } with c.OptionsCtx() as options: max_pipe_length = options.max_pipe_length = 10 conv1 = c.item(0).pipe(c.item(1).pipe(c.item(2))) def measure_pipe_length(conv): length = 0 for i in range(max_pipe_length): if conv._predefined_input is not None: length += 1 conv = conv._predefined_input else: break return length pipe_length_before = measure_pipe_length(conv1) for i in range(max_pipe_length + 20): c.generator_comp(c.this().pipe(conv1)) pipe_length_after = measure_pipe_length(conv1) assert pipe_length_after == pipe_length_before
def test_group_by_with_pipes(): # fmt: off input_data = [ { "name": "John", "started_at": date(2020, 1, 1), "stopped_at": None, "product": "A" }, { "name": "John", "started_at": date(2020, 1, 1), "stopped_at": date(2020, 1, 2), "product": "B" }, { "name": "John", "started_at": date(2020, 1, 1), "stopped_at": None, "product": "C" }, { "name": "Nick", "started_at": date(2020, 1, 1), "stopped_at": None, "product": "D" }, { "name": "Nick", "started_at": date(2020, 2, 1), "stopped_at": None, "product": "D" }, { "name": "Nick", "started_at": date(2020, 2, 1), "stopped_at": None, "product": "E" }, ] # fmt: on output = (c.group_by( c.item("name"), c.item("started_at"), ).aggregate({ "name": c.item("name"), "started_at": c.item("started_at"), "products": c.ReduceFuncs.ArrayDistinct( c.if_( c.item("stopped_at").is_(None), c.item("product"), None, ), ).pipe(c.filter(c.this())).pipe( c.call_func(sorted, c.this()).pipe( c(", ").call_method("join", c.this()))).pipe(c.this()), }).execute(input_data)) # fmt: off assert output == [{ 'name': 'John', 'products': 'A, C', 'started_at': date(2020, 1, 1) }, { 'name': 'Nick', 'products': 'D', 'started_at': date(2020, 1, 1) }, { 'name': 'Nick', 'products': 'D, E', 'started_at': date(2020, 2, 1) }] # fmt: on reducer = c.ReduceFuncs.Array(c.this(), default=list) output = (c.group_by( c.this()["name"], c.this()["started_at"], ).aggregate({ "name": c.this()["name"], "started_at": c.this()["started_at"], "products": c.this()["product"].pipe(reducer)[:3], }).execute(input_data)) assert output == [ { "name": "John", "products": ["A", "B", "C"], "started_at": date(2020, 1, 1), }, { "name": "Nick", "products": ["D"], "started_at": date(2020, 1, 1), }, { "name": "Nick", "products": ["D", "E"], "started_at": date(2020, 2, 1), }, ]
def test_doc__index_word_count(): # Let's say we need to count words across all files input_data = [ "war-and-peace-1.txt", "war-and-peace-2.txt", "war-and-peace-3.txt", "war-and-peace-4.txt", ] # # iterate an input and read file lines # # def read_file(filename): # with open(filename) as f: # for line in f: # yield line # extract_strings = c.generator_comp(c.call_func(read_file, c.this())) # to simplify testing extract_strings = c.generator_comp( c.call_func(lambda filename: [filename], c.this())) # 1. make ``re`` pattern available to the code to be generated # 2. call ``finditer`` method of the pattern and pass the string # as an argument # 3. pass the result to the next conversion # 4. iterate results, call ``.group()`` method of each re.Match # and call ``.lower()`` on each result split_words = (c.naive(re.compile(r"\w+")).call_method( "finditer", c.this()).pipe( c.generator_comp(c.this().call_method("group", 0).call_method("lower")))) # ``extract_strings`` is the generator of strings # so we iterate it and pass each item to ``split_words`` conversion vectorized_split_words = c.generator_comp(c.this().pipe(split_words)) # flattening the result of ``vectorized_split_words``, which is # a generator of generators of strings flatten = c.call_func( chain.from_iterable, c.this(), ) # aggregate the input, the result is a single dict # words are keys, values are count of words dict_word_to_count = c.aggregate( c.ReduceFuncs.DictCount(c.this(), c.this(), default=dict)) # take top N words by: # - call ``.items()`` method of the dict (the result of the aggregate) # - pass the result to ``sorted`` # - take the slice, using input argument named ``top_n`` # - cast to a dict take_top_n = (c.this().call_method("items").sort( key=lambda t: t[1], reverse=True).pipe(c.this()[:c.input_arg("top_n")]).as_type(dict)) # the resulting pipeline is pretty self-descriptive, except the ``c.if_`` # part, which checks the condition (first argument), # and returns the 2nd if True OR the 3rd (input data by default) otherwise pipeline = ( extract_strings.pipe(flatten).pipe(vectorized_split_words).pipe( flatten).pipe(dict_word_to_count).pipe( c.if_( c.input_arg("top_n").is_not(None), c.this().pipe(take_top_n), )) # Define the resulting converter function signature. In fact this # isn't necessary if you don't need to specify default values ).gen_converter(debug=True, signature="data_, top_n=None") assert pipeline(input_data, top_n=3) == {"war": 4, "and": 4, "peace": 4}
def test_gen_converter(): class A: x = 10 def __init__(self): self.x = 20 conv1 = (c.this() + c.input_arg("self").attr("x")).gen_converter(method=True) conv2 = (c.this + c.input_arg("cls").attr("x")).gen_converter(method=True) conv3 = classmethod( (c.this + c.input_arg("cls").attr("x")).gen_converter(class_method=True)) conv4 = classmethod( (c.this + c.input_arg("self").attr("x")).gen_converter(class_method=True)) conv5 = (c.this + c.input_arg("self").attr("x") + c.input_arg("n")).gen_converter( signature="self, n=1000, data_=15") conv6 = staticmethod( ((c.this + c.call_func(sum, c.input_arg("args"))) * c.input_arg("kwargs").call_method("get", "multiplicator", 1) ).gen_converter(signature="data_, *args, **kwargs")) with pytest.raises(ValueError): (Namespace( c.call_func(list).pipe( c.if_( LazyEscapedString("abc"), c.this() * LazyEscapedString("abc") * c.input_arg("abc"), c.this, )), {"abc": "(0 + 1)"}, )).execute(1, abc=10) assert A().conv1(100) == 120 assert A.conv3(100) == 110 with pytest.raises(NameError): A().conv2(100) with pytest.raises(NameError): A.conv4(100) assert A().conv5() == 1035 assert A().conv5(data_=7) == 1027 assert A().conv5(n=100) == 135 assert A.conv6(20) == 20 assert A.conv6(20, 1, 2, 3) == 26 assert A.conv6(20, 1, 2, 3, multiplicator=10) == 260 assert (c.call_func(sum, c.this).gen_converter(signature="*data_")(1, 2, 3) == 6) assert (c.call_func(lambda i: globals().__setitem__("A", 1) or sum(i), c.this).gen_converter(signature="*data_")(1, 2, 3) == 6) assert c({ c.naive("-").call_method("join", c.this.call_method("keys")): c.call_func(sum, c.this.call_method("values")) }).gen_converter(signature="**data_")(a=1, b=2, c=3) == { "a-b-c": 6 } with pytest.raises(c.ConversionException): c.call_func(sum, c.input_arg("x")).gen_converter(signature="*data_")(1, 2, 3) with pytest.raises(c.ConversionException): c.this.gen_converter(method=True, class_method=True)