Rename pipeline to code

Author: akb

README.rst

@@ -341,7 +341,7 @@ Define new commands in your config file which provide aliases to other commands.
    [[alias.stage]]
 
    command = "map"
-   options = {pipeline="json.loads ! types.SimpleNameSpace(**x)"}
+   options = {code="json.loads ! types.SimpleNameSpace(**x)"}
 
 
 Now we can use it like a regular command:
@@ -383,7 +383,7 @@ Convenient for removing trailing commas.
         [[alias.stage]]
 
         command = "stack"
-        options = {pipeline="yaml.safe_load ! json.dumps"}
+        options = {code="yaml.safe_load ! json.dumps"}
 
 Search for xpath elements with xpath
 +++++++++++++++++++++++++++++++++++++++++
@@ -420,7 +420,7 @@ Pull text out of xml documents.
 
         [[alias.stage]]
         command = "stack"
-        options= {pipeline="x.encode() ! io.BytesIO ! lxml.etree.parse ! x.findall(query) ! map(lambda y: y, x) ! list" }
+        options= {code="x.encode() ! io.BytesIO ! lxml.etree.parse ! x.findall(query) ! map(lambda y: y, x) ! list" }
 
         [[alias.stage]]
         command="chain"
@@ -447,26 +447,26 @@ Generate json objects
 
         [[alias.stage]]
         command = "eval"
-        options = {pipeline="pairs"}
+        options = {code="pairs"}
 
         [[alias.stage]]
         command = "map"
-        options = {pipeline="shlex.split(x, posix=False)"}
+        options = {code="shlex.split(x, posix=False)"}
 
         [[alias.stage]]
         command = "chain"
 
         [[alias.stage]]
         command = "map"
-        options = {pipeline="x.partition('=') ! [x[0], ast.literal_eval(re.sub(r'^(?P<value>[A-Za-z]+)$', r'\"\\g<value>\"', x[2]))]"}
+        options = {code="x.partition('=') ! [x[0], ast.literal_eval(re.sub(r'^(?P<value>[A-Za-z]+)$', r'\"\\g<value>\"', x[2]))]"}
 
         [[alias.stage]]
         command = "apply"
-        options = {"pipeline"="dict"}
+        options = {"code"="dict"}
 
         [[alias.stage]]
         command = "map"
-        options = {pipeline="json.dumps"}
+        options = {code="json.dumps"}
 
 
 

src/mario/interpret.py

@@ -131,21 +131,21 @@ async def _mario_runner({howsig.value}):
     return source
 
 
-def build_name_to_module(pipeline):
+def build_name_to_module(code):
     name_to_module = {}
-    components = split_pipestring(pipeline)
+    components = split_pipestring(code)
     module_names = {name for c in components for name in find_maybe_module_names(c)}
     for name in module_names:
         name_to_module.update(_get_autoimport_module(name))
 
     return name_to_module
 
 
-def build_function(pipeline, global_namespace, howcall):
-    name_to_module = build_name_to_module(pipeline)
+def build_function(code, global_namespace, howcall):
+    name_to_module = build_name_to_module(code)
     global_namespace = {**name_to_module, **global_namespace}
 
-    source = build_source(split_pipestring(pipeline), howcall)
+    source = build_source(split_pipestring(code), howcall)
     exec(source, global_namespace)
     function = global_namespace["_mario_runner"]
     return Function(function, global_namespace, source)

src/mario/plugins/basic.py

@@ -25,11 +25,11 @@ def calculate_function(traversal, howcall=None):
             )
         )
 
-    if "pipeline" in traversal.specific_invocation_params:
+    if "code" in traversal.specific_invocation_params:
 
         return {
             "function": interpret.build_function(
-                traversal.specific_invocation_params["pipeline"],
+                traversal.specific_invocation_params["code"],
                 global_namespace=global_namespace,
                 howcall=howcall,
             )
@@ -41,7 +41,7 @@ def calculate_function(traversal, howcall=None):
 def calculate_reduce(traversal):
 
     function = interpret.build_function(
-        traversal.specific_invocation_params["pipeline"],
+        traversal.specific_invocation_params["code"],
         traversal.global_invocation_options.global_options["global_namespace"],
         howcall=interpret.HowCall.VARARGS,
     )
@@ -146,38 +146,37 @@ async def async_chain(items, exit_stack):
 
 
 subcommands = [
-    click.Command("map", short_help="Call <pipeline> on each line of input."),
-    click.Command("async-map", short_help="Call <pipeline> on each line of input."),
-    click.Command("apply", short_help="Call <pipeline> on input as a sequence."),
+    click.Command("map", short_help="Call <code> on each line of input."),
+    click.Command("async-map", short_help="Call <code> on each line of input."),
+    click.Command("apply", short_help="Call <code> on input as a sequence."),
     click.Command(
-        "async-apply",
-        short_help="Call <pipeline> asynchronously on input as a sequence.",
+        "async-apply", short_help="Call <code> asynchronously on input as a sequence."
     ),
     click.Command(
         "filter",
-        short_help="Call <pipeline> on each line of input and exclude false values.",
+        short_help="Call <code> on each line of input and exclude false values.",
     ),
     click.Command(
         "async-filter",
-        short_help="Async call <pipeline> on each line of input and exclude false values.",
+        short_help="Async call <code> on each line of input and exclude false values.",
     ),
     click.Command(
-        "stack", short_help="Call <pipeline> on input as a single concatenated string."
+        "stack", short_help="Call <code> on input as a single concatenated string."
     ),
     click.Command(
         "async-map-unordered",
-        short_help="Call <pipeline> on each line of input, ignoring order of input items.",
+        short_help="Call <code> on each line of input, ignoring order of input items.",
     ),
     click.Command(
         "dropwhile",
         short_help="Evaluate <predicate> on function and drop values until first falsy.",
     ),
-    click.Command("eval", short_help="Evaluate a python expression <pipeline>"),
+    click.Command("eval", short_help="Evaluate a python expression <code>"),
 ]
 
 
 def build_callback(sub_command):
-    def callback(pipeline, autocall, **parameters):
+    def callback(code, autocall, **parameters):
         if autocall:
             howcall = interpret.HowCall.SINGLE
         else:
@@ -187,7 +186,7 @@ def callback(pipeline, autocall, **parameters):
             {
                 "name": sub_command.name.replace("-", "_"),
                 "howcall": howcall,
-                "pipeline": pipeline,
+                "code": code,
                 "parameters": parameters,
             }
         ]
@@ -203,7 +202,7 @@ def callback(pipeline, autocall, **parameters):
 
     subcommand.params = [
         click.Option(["--autocall/--no-autocall"], is_flag=True, default=True),
-        click.Argument(["pipeline"]),
+        click.Argument(["code"]),
     ]
     subcommand.callback = build_callback(subcommand)
     subcommand = option_exec_before(subcommand)
@@ -220,19 +219,19 @@ def callback(pipeline, autocall, **parameters):
 def _reduce(function_name, **parameters):
     return [
         {
-            "pipeline": f"toolz.curry({function_name})",
+            "code": f"toolz.curry({function_name})",
             "name": "reduce",
             "parameters": parameters,
         }
     ]
 
 
 # @registry.add_cli(name="eval")
-# @click.command("eval", short_help="Call <pipeline> without any input.")
+# @click.command("eval", short_help="Call <code> without any input.")
 # @option_exec_before
 # @click.argument("expression")
 # def _eval(expression, **parameters):
-#     return [{"pipeline": expression, "name": "eval", "parameters": parameters}]
+#     return [{"code": expression, "name": "eval", "parameters": parameters}]
 
 
 more_commands = [

tests/data/config/jsonl_alias.toml

@@ -6,4 +6,4 @@ short_help = "Load jsonlines into python objects"
 [[alias.stage]]
 
 command = "map"
-options = {pipeline="json.loads ! attr.make_class('X', list(x.keys()))(**x)"}
+options = {code="json.loads ! attr.make_class('X', list(x.keys()))(**x)"}

tests/test_app.py

@@ -53,7 +53,7 @@ def test_raises_on_nonexistent_option(option, runner):
 
 
 def test_eval_main(capsys):
-    mario.app.main([[{"name": "eval", "pipeline": "1+1", "parameters": {}}]])
+    mario.app.main([[{"name": "eval", "code": "1+1", "parameters": {}}]])
     assert capsys.readouterr().out == "2\n"