REFACT: FunctionalOperation-->FnOp

Author: ankostis

CHANGES.rst

@@ -183,7 +183,7 @@ v9.0.0.dev2 (30 Jun 2020, @ankostis): JSONP; net, evictions & sfxed fixes; conve
     when a pipeline fails.
 
 + DOC(op): table explaining the differences between various dependency attributes of
-  :class:`.FunctionalOperation`.
+  :class:`.FnOp`.
 
   .. include:: ../../graphtik/op.py
       :start-after: .. dep-attributes-start
@@ -203,7 +203,7 @@ v9.0.0.dev2 (30 Jun 2020, @ankostis): JSONP; net, evictions & sfxed fixes; conve
 
 v8.4.0 (15 May 2020, @ankostis): subclass-able Op, plot edges from south-->north of nodes
 =========================================================================================
-+ ENH(pipe): nest all Ops (not just FnOps), dropping ``FunctionalOperation``
++ ENH(pipe): nest all Ops (not just FnOps), dropping ``FnOp``
   dependency in network code, to **allow for further sub-classing** :class:`Operation`.
 + FIX(pipeline): due to a side-effect on a ``kw`` dictionary, it was mixing the attributes
   of earlier operations into later ones while merging them into pipelines.
@@ -343,7 +343,7 @@ NET: fix rescheduled, cancelable sfx, improve compute API
 + ENH(OP): more intuitive API, ``compute()`` may be called with no args,
   or a single string as `outputs` param.  Operation's ``__call__`` now delegates
   to ``compute()`` - to quickly experiment with function, access it from the
-  operation's :attr:`.FunctionalOperation.fn` attribute
+  operation's :attr:`.FnOp.fn` attribute
 
 MODIFIERS: modifier combinations, rename sol_sideffects
 -------------------------------------------------------
@@ -397,7 +397,7 @@ v7.0.0 (28 Apr 2020, @ankostis): In-solution sideffects, unified OpBuilder, plot
 
 + BREAK(op): The :func:`.operation` factory function (used to be *class*) now behave
   like a regular decorator when `fn` given in the first call, and constructs
-  the :class:`.FunctionalOperation` without a need to call again the factory.
+  the :class:`.FnOp` without a need to call again the factory.
 
   Specifically the last empty call at the end ``()`` is not needed (or possible)::
 
@@ -418,7 +418,7 @@ MODIFIERS: Sideffecteds;  arg--> mapped
   "cycles":
 
   + feat(op): introduce ``_fn_needs``, ``op_needs`` & ``op_provides`` on
-    :class:`.FunctionalOperation`, used when matching Inps/Outs and when pruning
+    :class:`.FnOp`, used when matching Inps/Outs and when pruning
     graph.
   + FEAT(op): print detailed deps when DEBUG enabled.
 
@@ -760,7 +760,7 @@ Details
 + FIX(NET): keep Solution's insertion order also for PARALLEL executions.
 
 + FEAT(NET, OP): :term:`reschedule`\d operations with partial outputs;
-  they must have :attr:`.FunctionalOperation.rescheduled` set to true,
+  they must have :attr:`.FnOp.rescheduled` set to true,
   or else they will fail.
 
 + FEAT(OP, netop): specify :term:`endurance`/`reschedule` on a per operation basis,
@@ -894,7 +894,7 @@ v4.0.0 (11 Dec 2019, @ankostis): NESTED merge, revert v3.x Unvarying, immutable
 + BREAK/REFACT(OP): simplify hierarchy, make :class:`.Operation` fully abstract,
   without name or requirements.
 
-  + enh: make :class:`.FunctionalOperation` IMMUTABLE, by inheriting
+  + enh: make :class:`.FnOp` IMMUTABLE, by inheriting
     from class:`.namedtuple`.
 
 + refact(net): consider as netop `needs` also intermediate data nodes.
@@ -999,7 +999,7 @@ v2.2.0 (20 Nov 2019, @ankostis): enhance OPERATIONS & restruct their modules
 + BREAK(op): drop unused `Operation._after_init()` pickle-hook; use `dill` instead.
 + refact(op): convert :meth:`Operation._validate()` into a function,
   to be called by clients wishing to automate operation construction.
-+ refact(op): replace ``**kwargs`` with named-args in class:`FunctionalOperation`,
++ refact(op): replace ``**kwargs`` with named-args in class:`FnOp`,
   because it allowed too wide args, and offered no help to the user.
 + REFACT(configs): privatize ``network._execution_configs``; expose more
   config-methods from base package.

docs/source/arch.rst

@@ -36,7 +36,7 @@ Architecture
 
         .. autosummary::
 
-            graphtik.op.FunctionalOperation
+            graphtik.op.FnOp
             graphtik.pipeline.Pipeline
             graphtik.planning.Network
             graphtik.execution.ExecutionPlan
@@ -56,7 +56,7 @@ Architecture
         <dependency>`.
 
         .. Tip::
-            - Use :func:`.operation` factory to construct :class:`.FunctionalOperation`
+            - Use :func:`.operation` factory to construct :class:`.FnOp`
               instances (a.k.a. operations).
             - Use :func:`.compose()` factory to build :class:`.Pipeline`
               instances (a.k.a. pipelines).
@@ -160,7 +160,7 @@ Architecture
         This layering is disabled if a `jsonp` `dependency` exists in the `network`,
         assuming that :func:`.set_layered_solution` `configurations` has not been
         called with a ``True/False``, nor has the respective parameter been given
-        to methods :meth:`~.FunctionalOperation.compute()`/:meth:`~.ExecutionPlan.execute()`.
+        to methods :meth:`~.FnOp.compute()`/:meth:`~.ExecutionPlan.execute()`.
 
         .. hint::
 
@@ -257,7 +257,7 @@ Architecture
 
     operation
         Either the abstract notion of an action with specified `needs` and `provides`,
-        *dependencies*, or the concrete wrapper :class:`.FunctionalOperation` for
+        *dependencies*, or the concrete wrapper :class:`.FnOp` for
         (any :func:`callable`), that feeds on `inputs` and update `outputs`,
         from/to `solution`, or given-by/returned-to the user by a `pipeline`.
 
@@ -269,7 +269,7 @@ Architecture
         The (possibly `hierarchical <subdoc>`) name of a `solution` value an `operation` `needs` or `provides`.
 
         - *Dependencies* are declared during `composition`, when building
-          :class:`.FunctionalOperation` instances.
+          :class:`.FnOp` instances.
           *Operations* are then interlinked together, by matching the *needs* & *provides*
           of all *operations* contained in a `pipeline`.
 
@@ -328,14 +328,14 @@ Architecture
     default identity function
         The default function if none given to an `operation` that conveys `needs` to `provides`.
 
-        For this to happen when :meth:`.FunctionalOperation.compute()` is called,
+        For this to happen when :meth:`.FnOp.compute()` is called,
         an operation *name* must have been given AND the number of `provides` must match
         that of the number of `needs`.
 
         :seealso: :ref:`conveyor-function` & :func:`.identity_function()`.
 
     returns dictionary
-        When an `operation` is marked with :attr:`FunctionalOperation.returns_dict` flag,
+        When an `operation` is marked with :attr:`FnOp.returns_dict` flag,
         the underlying function is not expected to return `fn_provides` as a sequence
         but as a dictionary; hence, no "zipping" of function-results --> `fn_provides`
         takes place.
@@ -487,7 +487,7 @@ Architecture
         The partial `pruning` of the `solution`'s dag during `execution`.
         It happens when any of these 2 conditions apply:
 
-        - an `operation` is marked with the :attr:`.FunctionalOperation.rescheduled`
+        - an `operation` is marked with the :attr:`.FnOp.rescheduled`
           attribute, which means that its underlying *callable* may produce
           only a subset of its `provides` (*partial outputs*);
         - `endurance` is enabled, either globally (in the `configurations`), or
@@ -505,7 +505,7 @@ Architecture
     endured
         Keep executing as many `operation`\s as possible, even if some of them fail.
         Endurance for an operation  is enabled if :func:`.set_endure_operations()`
-        is true globally in the `configurations` or if :attr:`.FunctionalOperation.endured`
+        is true globally in the `configurations` or if :attr:`.FnOp.endured`
         is true.
 
         You may interrogate :attr:`.Solution.executed` to discover the status
@@ -563,7 +563,7 @@ Architecture
 
     plottable
         Objects that can plot their graph network, such as those inheriting :class:`.Plottable`,
-        (:class:`.FunctionalOperation`, :class:`.Pipeline`, :class:`.Network`,
+        (:class:`.FnOp`, :class:`.Pipeline`, :class:`.Network`,
         :class:`.ExecutionPlan`, :class:`.Solution`) or a |pydot.Dot|_ instance
         (the result of the :meth:`.Plottable.plot()` method).
 

docs/source/operations.rst

@@ -24,7 +24,7 @@ to retrofitting existing *functions* unaware of all these, into :term:`operation
 
 Operations from existing functions
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-The :class:`.FunctionalOperation` provides a concrete lightweight wrapper
+The :class:`.FnOp` provides a concrete lightweight wrapper
 around any arbitrary function to define and execute within a *pipeline*.
 Use the :func:`.operation()` factory to instantiate one:
 
@@ -35,16 +35,16 @@ Use the :func:`.operation()` factory to instantiate one:
    ...                    needs=['a', 'b'],
    ...                    provides=['a_plus_b'])
    >>> add_op
-   FunctionalOperation(name='add', needs=['a', 'b'], provides=['a_plus_b'], fn='add')
+   FnOp(name='add', needs=['a', 'b'], provides=['a_plus_b'], fn='add')
 
-You may still call the original function at :attr:`.FunctionalOperation.fn`,
+You may still call the original function at :attr:`.FnOp.fn`,
 bypassing thus any operation pre-processing:
 
       >>> add_op.fn(3, 4)
       7
 
 But the proper way is to *call the operation* (either directly or by calling the
-:meth:`.FunctionalOperation.compute()` method).  Notice though that unnamed
+:meth:`.FnOp.compute()` method).  Notice though that unnamed
 positional parameters are not supported:
 
       >>> add_op(a=3, b=4)
@@ -58,7 +58,7 @@ positional parameters are not supported:
 
 Builder pattern
 ^^^^^^^^^^^^^^^
-There are two ways to instantiate a :class:`.FunctionalOperation`\s, each one suitable
+There are two ways to instantiate a :class:`.FnOp`\s, each one suitable
 for different scenarios.
 
 We've seen that calling manually :func:`.operation()` allows putting into a pipeline
@@ -69,7 +69,7 @@ with similar attributes, e.g. ``needs``:
 
    >>> op_factory = operation(needs=['a'])
 
-Notice that we specified a `fn`, in order to get back a :class:`.FunctionalOperation`
+Notice that we specified a `fn`, in order to get back a :class:`.FnOp`
 instance (and not a decorator).
 
    >>> from graphtik import operation, compose
@@ -134,8 +134,8 @@ to the :func:`.operation` factory, specifically:
 
    It can be a single string, in which case a 1-element iterable is assumed.
 
-   :seealso: :term:`needs`, :term:`modifier`, :attr:`.FunctionalOperation.needs`,
-      :attr:`.FunctionalOperation.op_needs`, :attr:`.FunctionalOperation._fn_needs`
+   :seealso: :term:`needs`, :term:`modifier`, :attr:`.FnOp.needs`,
+      :attr:`.FnOp.op_needs`, :attr:`.FnOp._fn_needs`
 
 ``provides``
    this argument names the list of (positionally ordered) :term:`outputs` data
@@ -148,8 +148,8 @@ to the :func:`.operation` factory, specifically:
    If they are more than one, the underlying function must return an iterable
    with same number of elements (unless it :term:`returns dictionary`).
 
-   :seealso: :term:`provides`, :term:`modifier`, :attr:`.FunctionalOperation.provides`,
-      :attr:`.FunctionalOperation.op_provides`, :attr:`.FunctionalOperation._fn_provides`
+   :seealso: :term:`provides`, :term:`modifier`, :attr:`.FnOp.provides`,
+      :attr:`.FnOp.op_provides`, :attr:`.FnOp._fn_provides`
 
 Declarations of *needs* and *provides* is affected by :term:`modifier`\s like
 :func:`.keyword`:

docs/source/pipelines.rst

@@ -261,7 +261,7 @@ are raising errors, if they are marked as :term:`endured`:
     ... def get_out():
     ...     raise ValueError("Quarantined!")
     >>> get_out
-    FunctionalOperation!(name='get_out', provides=['space', 'time'], fn='get_out')
+    FnOp!(name='get_out', provides=['space', 'time'], fn='get_out')
 
 Notice the exclamation(``!``) before the parenthesis in the string representation
 of the operation.
@@ -325,7 +325,7 @@ actual `provides` delivered:
     ...     else:
     ...          return {"space": "around the block"}
     >>> get_out_or_stay_home
-    FunctionalOperation?(name='get_out_or_stay_home',
+    FnOp?(name='get_out_or_stay_home',
                          needs=['quarantine'],
                          provides=['space', 'time'],
                          fn{}='get_out_or_stay_home')

docs/source/plotting.rst

@@ -32,7 +32,7 @@ solution of the last computation, calling methods with arguments like this::
 
 The same :meth:`.Plottable.plot()` method applies also for:
 
-- :class:`.FunctionalOperation`
+- :class:`.FnOp`
 - :class:`.Pipeline`
 - :class:`.Network`
 - :class:`.ExecutionPlan`
@@ -251,7 +251,7 @@ Directives
 
       the variable name containing what to render, which it can be:
 
-      - an instance of :class:`.Plottable` (such as :class:`.FunctionalOperation`,
+      - an instance of :class:`.Plottable` (such as :class:`.FnOp`,
         :class:`.Pipeline`, :class:`.Network`, :class:`.ExecutionPlan` or
         :class:`.Solution`);
 
@@ -506,21 +506,21 @@ in :term:`parallel`::
    DEBUG    ... cache-updated key: ((), None, None)
    DEBUG    === (3C40) Executing pipeline(t), in parallel, on inputs[], according to ExecutionPlan(needs=[], provides=['b'], x2 steps: op1, op2)...
    DEBUG    +++ (3C40) Parallel batch['op1'] on solution[].
-   DEBUG    +++ (3C40) Executing OpTask(FunctionalOperation|(name='op1', needs=[], provides=[sfx: 'b'], fn{}='<lambda>'), sol_keys=[])...
+   DEBUG    +++ (3C40) Executing OpTask(FnOp|(name='op1', needs=[], provides=[sfx: 'b'], fn{}='<lambda>'), sol_keys=[])...
    INFO     graphtik.op.py:534 Results[sfx: 'b'] contained +1 unknown provides[sfx: 'b']
-   FunctionalOperation|(name='op1', needs=[], provides=[sfx: 'b'], fn{}='<lambda>')
+   FnOp|(name='op1', needs=[], provides=[sfx: 'b'], fn{}='<lambda>')
    DEBUG    ... (3C40) op(op1) completed in 1.406ms.
 
    ...
 
    DEBUG    === Compiling pipeline(t)...
    DEBUG    ... cache-hit key: ((), None, None)
    DEBUG    === (8697) Executing pipeline(t), evicting, on inputs[], according to ExecutionPlan(needs=[], provides=['b'], x3 steps: op1, op2, sfx: 'b')...
-   DEBUG    +++ (8697) Executing OpTask(FunctionalOperation(name='op1', needs=[], provides=[sfx: 'b'], fn{}='<lambda>'), sol_keys=[])...
+   DEBUG    +++ (8697) Executing OpTask(FnOp(name='op1', needs=[], provides=[sfx: 'b'], fn{}='<lambda>'), sol_keys=[])...
    INFO     graphtik.op.py:534 Results[sfx: 'b'] contained +1 unknown provides[sfx: 'b']
-   FunctionalOperation(name='op1', needs=[], provides=[sfx: 'b'], fn{}='<lambda>')
+   FnOp(name='op1', needs=[], provides=[sfx: 'b'], fn{}='<lambda>')
    DEBUG    ... (8697) op(op1) completed in 0.149ms.
-   DEBUG    +++ (8697) Executing OpTask(FunctionalOperation(name='op2', needs=[sfx: 'b'], provides=['b'], fn='<lambda>'), sol_keys=[sfx: 'b'])...
+   DEBUG    +++ (8697) Executing OpTask(FnOp(name='op2', needs=[sfx: 'b'], provides=['b'], fn='<lambda>'), sol_keys=[sfx: 'b'])...
    DEBUG    ... (8697) op(op2) completed in 0.08ms.
    DEBUG    ... (8697) evicting 'sfx: 'b'' from solution[sfx: 'b', 'b'].
    DEBUG    === (8697) Completed pipeline(t) in 0.229ms.
@@ -562,13 +562,13 @@ with the following properties, as a debug aid:
 {'aliases': None,
  'args': {'kwargs': {}, 'positional': [None], 'varargs': []},
  'network': Network(x3 nodes, x1 ops: screamer),
- 'operation': FunctionalOperation(name='screamer', needs=['a'], provides=['foo'], fn='scream'),
+ 'operation': FnOp(name='screamer', needs=['a'], provides=['foo'], fn='scream'),
  'outputs': None,
  'plan': ExecutionPlan(needs=['a'], provides=['foo'], x1 steps: screamer),
  'results_fn': None,
  'results_op': None,
  'solution': {'a': None},
- 'task': OpTask(FunctionalOperation(name='screamer', needs=['a'], provides=['foo'], fn='scream'), sol_keys=['a'])}
+ 'task': OpTask(FnOp(name='screamer', needs=['a'], provides=['foo'], fn='scream'), sol_keys=['a'])}
 
 
 In interactive *REPL* console you may use this to get the last raised exception::
@@ -633,7 +633,7 @@ problems with computed values.
 Accessing wrapper operation from task-context
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Alternatively, when the debugger is stopped inside an underlying function,
-you may access the wrapper :class:`.FunctionalOperation` and the :class:`.Solution`
+you may access the wrapper :class:`.FnOp` and the :class:`.Solution`
 through the :data:`graphtik.execution.task_context` context-var.
 This is populated with the :class:`._OpTask` instance of the currently executing operation,
 as shown in the :mod:`pdb` session printout, below::
@@ -659,7 +659,7 @@ Printing the operation-task gives you a quick overview of the operation and
 the available solution keys (but not the values, not to clutter the debugger console)::
 
    (Pdb) p op_task
-   OpTask(FunctionalOperation(name=..., needs=..., provides=..., fn=...), sol_keys=[...])
+   OpTask(FnOp(name=..., needs=..., provides=..., fn=...), sol_keys=[...])
 
 Print the wrapper operation::
 

graphtik/base.py

@@ -896,7 +896,7 @@ def _rename_graph_names(
             all data are extracted 1st from this kw, falling back on the operation's
             attributes, and it is modified in-place
 
-        For the other 2 params, see :meth:`.FunctionalOperation.withset()`.
+        For the other 2 params, see :meth:`.FnOp.withset()`.
 
         :raise ValueError:
             - if a `renamer` was neither dict nor callable

graphtik/config.py

@@ -88,7 +88,7 @@ def _tristate_armed(context_var: ContextVar, enabled):
 
 .. debug-behavior-start
 
-+ :meth:`FunctionalOperation.compute()` raise any matching-needs errors immediately;
++ :meth:`FnOp.compute()` raise any matching-needs errors immediately;
 + net objects print details recursively;
 + plotted SVG diagrams include style-provenance as tooltips;
 + Sphinx extension also saves the original DOT file next to each image