break(MODIF) Forbid Implicit SFXEDs ...

hard to find a solid use-case that
pure `sfx` would'nt solve.
Also need some space for converting sfx-list -> implicits.

Author: ankostis

graphtik/modifier.py

@@ -47,6 +47,7 @@
 #: Arguments-presence patterns for :class:`_Modifier` constructor.
 #: Combinations missing raise errors.
 _modifier_cstor_matrix = {
+# TODO: Add `implicit` in the table, to augment REPR & forbid implicit sfxed.
 # (7, kw, opt, accessors, sfxed, sfx): (STR, REPR, FUNC) OR None
 700000: None,
 710000: (       "%(dep)s",                  "'%(dep)s'(%(acs)s>%(kw)s)",    "keyword"),
@@ -248,7 +249,14 @@ def __new__(
             accessor.validate()
         if sideffected and is_sfx(sideffected):
             raise ValueError(
-                f"`sideffected` cannot be sideffect, got {sideffected!r}"
+                f"`sideffected` cannot be `sfx`, got {sideffected!r}"
+                f"\n  locals={locals()}"
+            )
+
+        # TODO: Add `implicit` in the table, to augment REPR & forbid implicit sfxed.
+        if sideffected and kw.get("_implicit"):
+            raise ValueError(
+                f"`sideffected` cannot be `implicit`, got {sideffected!r}"
                 f"\n  locals={locals()}"
             )
         double_sideffects = [
@@ -1080,14 +1088,13 @@ def sfxed(
     optional: bool = None,
     accessor: Accessor = None,
     jsonp=None,
-    implicit=None,
 ) -> _Modifier:
     r"""
     Annotates a :term:`sideffected` dependency in the solution sustaining side-effects.
 
     :param dependency:
         the actual dependency receiving the sideffect, which will be fed into/out
-        of the function (unless marked as :term:`implicit`).
+        of the function.
     :param sfx0:
         the 1st (arbitrary object) sideffect marked as "acting" on the `dependency`.
     :param sfx0:
@@ -1103,8 +1110,6 @@ def sfxed(
     :param jsonp:
         None (derrived from `name`), ``False``, str, collection of str/callable (last one)
         See generic :func:`.modify` modifier.
-    :param implicit:
-        :term:`implicit` dependencies are not fed into/out of the function.
 
     Like :func:`.sfx` but annotating a *real* :term:`dependency` in the solution,
     allowing that dependency to be present both in :term:`needs` and :term:`provides`
@@ -1195,7 +1200,6 @@ def sfxed(
         sfx_list=(sfx0, *sfx_list),
         accessor=accessor,
         jsonp=jsonp,
-        implicit=implicit,
     )
 
 

test/test_base.py

@@ -275,15 +275,15 @@ def test_jetsam_n_plot_with_DEBUG():
                 "a",
                 sfxed("b", "foo", keyword="bb"),
                 implicit("c"),
-                sfxed("d", "bar", implicit=1),
+                sfxed("d", "bar"),
                 vararg("e"),
                 varargs("f"),
             ],
             provides=[
                 "A",
                 sfxed("b", "FOO", keyword="bb"),
                 implicit("C"),
-                sfxed("d", "BAR", implicit=1),
+                sfxed("d", "BAR", optional=True),
                 sfx("FOOBAR"),
             ],
             aliases={"A": "aaa", "b": "bbb", "d": "ddd"},  # FIXME: "D" is implicit!

test/test_graphtik.py

@@ -12,6 +12,7 @@
 from graphtik import (
     NO_RESULT,
     compose,
+    implicit,
     modify,
     operation,
     optional,
@@ -136,22 +137,20 @@ def test_cycle_tip():
         pipe.compute()
 
 
-def test_aliases(exemethod):
-    provides = ("a", sfxed("s1", "foo"), sfxed("s2", "foo", implicit=1))
+def test_aliases_pipeline(exemethod):
+    provides = ("a", sfxed("s", "foo"))
     aliased = operation(
         lambda: ("A", "B"),
         name="op1",
         provides=provides,
-        aliases={"a": "b", "s1": "S1", "s2": "S2"},
+        aliases={"a": "b", "s": "S1"},
     )
     assert aliased._user_provides == provides
     assert tuple(aliased.provides) == (
         "a",
-        sfxed("s1", "foo"),
-        sfxed("s2", "foo"),
+        sfxed("s", "foo"),
         "b",
         "S1",
-        "S2",
     )
 
     pipe = compose(
@@ -160,7 +159,7 @@ def test_aliases(exemethod):
         operation(lambda x: x * 2, name="op2", needs="b", provides="c"),
         parallel=exemethod,
     )
-    assert pipe() == {"a": "A", "s1": "B", "b": "A", "S1": "B", "c": "AA"}
+    assert pipe() == {"a": "A", "s": "B", "b": "A", "S1": "B", "c": "AA"}
     assert list(pipe.provides) == [*aliased.provides, "c"]
 
 

test/test_modifier.py

@@ -341,12 +341,6 @@ def test_implicit(ser_method):
     assert is_implicit(m) is True
     m = optional("a", implicit=1)
     assert is_implicit(m) is 1
-    m = sfxed("a", "b")
-    assert is_implicit(m) is None
-    m = sfxed("a", "b", implicit=1)
-    assert is_implicit(m) == 1
-    m = sfxed("a", "b", "c", implicit=0)
-    assert is_implicit(m) == 0
 
     assert dep_renamed(m, "R")._implicit == m._implicit
     assert ser_method(m)._implicit == m._implicit

test/test_op.py

@@ -402,30 +402,6 @@ def test_as_renames(inp, exp):
             (["i"], {"i": implicit("II")}),
             ValueError("must not contain `implicits"),
         ),
-        ## Implicit SFXEDs
-        (
-            ([sfxed("i", "1", implicit=1)], {sfxed("i", "1", implicit=1): "II"}),
-            ValueError("must not contain `implicits"),
-        ),
-        (
-            ([sfxed("i", "1")], {sfxed("i", "1", implicit=1): "II"}),
-            ValueError("must not contain `implicits"),
-        ),
-        (
-            ([sfxed("i", "1", implicit=1)], {sfxed("i", "1"): "II"}),
-            ValueError("must not contain `implicits"),
-        ),
-        pytest.param(
-            ([sfxed("i", "1", implicit=1)], {"i": "II"}),
-            ValueError("must not contain `implicits"),
-            marks=pytest.mark.xfail(
-                reason="Would eliminate implicit sfxeds in the next commit"
-            ),
-        ),
-        (
-            (["i"], {"i": sfxed("II", "1", implicit=1)}),
-            ValueError("must not contain `implicits"),
-        ),
     ],
 )
 def test_func_op_validation_aliases_BAD(prov_aliases, ex):

test/test_sideffects.py

@@ -463,23 +463,3 @@ def test_implicit_out():
     assert got == {"A": ""}
 
     assert "(implicit)" in str(op.plot())
-
-
-def test_sfxed_implicit_inp():
-    op = operation(str, needs=["A", sfxed("a", "b", implicit=1)], provides="a")
-
-    pipe = compose(..., op)
-    got = pipe.compute({"A": "val", sfxed("a", "b"): 1}, "a")
-    assert got == {"a": "val"}
-
-    assert "(implicit)" in str(op.plot())
-
-
-def test_sfxed_implicit_out():
-    op = operation(str, "hh", provides=["A", sfxed("a", "b", implicit=1)])
-
-    pipe = compose(..., op)
-    got = pipe.compute()
-    assert got == {"A": ""}
-
-    assert "(implicit)" in str(op.plot())