Graphtik

==================================================================================
- [x] dynamic Reschedule after operations with partial outputs execute.
- [x] raise after jetsam.
- [x] plots link to legend.
- [x] refact netop
- [x] endurance per op.
- [x] endurance/reschedule for all netop ops.
- [x] merge _Rescheduler into Solution.
- [x] keep order of outputs in Solution even for parallels.
- [x] keep solution layers ordered also for parallel.
- [x] require user to create & enter pools.
- [x] FIX pickling THREAD POOL -->Process.

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:`.FnOp.rescheduled` set to true,
or else they will fail.

+ FEAT(OP, netop): specify :term:`endurance`/`reschedule` on a per operation basis,
or collectively for all operations grouped under some :term:`pipeline`.

+ REFACT(NETOP):

+ feat(netop): new method :meth:`.Pipeline.compile()`, delegating to
same-named method of `network`.

+ drop(net): method ``Net.narrowed()``; remember `netop.narrowed(outputs+predicate)`
and apply them on `netop.compute()` & ``netop.compile()``.

- PROS: cache narrowed plans.
- CONS: cannot review network, must review plan of (new) `netop.compile()`.

+ drop(netop): `inputs` args in `narrowed()` didn't make much sense,
leftover from "unvarying netops"; but exist ni `netop.compile()`.

+ refact(netop): move net-assembly from compose() --> NetOp cstor;
now reschedule/endured/merge/method args in cstor.

+ NET,OP,TCs: FIX PARALLEL POOL CONCURRENCY

+ Network:

+ feat: +marshal +_OpTask
+ refact: plan._call_op --> _handle_task
+ enh: Make `abort run` variable a *shared-memory* ``Value``.

+ REFACT(OP,.TC): not a namedtuple, breaks pickling.
+ ENH(pool): Pool
+ FIX: compare Tokens with `is` --> `==`,
or else, it won't work for sub-processes.
+ TEST: x MULTIPLE TESTS

+ +4 tags: parallel, thread, proc, marshal.
+ many uses of exemethod.

+ FIX(build): PyPi README check did not detect forbidden ``raw`` directives,
and travis auto-deployments were failing.

+ doc(arch): more terms.

========================================
+ FEAT(OP): support "aliases" of `provides`, to avoid trivial pipe-through operations,
just to rename & match operations.

==================================================
+ FEAT(NET): when :func:`.set_endure_operations` configuration is set to true,
a :term:`pipeline` will keep on calculating solution, skipping any operations
downstream from failed ones. The :term:`solution` eventually collects all failures
in ``Solution.failures`` attribute.

+ ENH(DOC,plot): Links in Legend and :ref:`arch` Workflow SVGs now work,
and delegate to *architecture* terms.

+ ENH(plot): mark :term:`overwrite`, *failed* & *canceled* in ``repr()``
(see :term:`endurance`).

+ refact(conf): fully rename configuration operation ``skip_evictions``.

+ REFACT(jetsam): raise after jetsam in situ, better for Readers & Linters.

+ enh(net): improve logging.

=========================================================================================
|v410-flowchart|

+ FIX(NET): TOPOLOGICALLY-sort now break ties respecting operations insertion order.

+ ENH(NET): new :class:`.Solution` class to collect all computation values,
based on a :class:`collections.ChainMap` to distinguish outputs per operation executed:

+ ENH(NETOP): ``compute()`` return :class:`.Solution`, consolidating:

+ :term:`overwrite`,
+ ``executed`` operations, and
+ the generating :term:`plan`.

+ drop(net): ``_PinInstruction`` class is not needed.
+ drop(netop): `overwrites_collector` parameter; now in :meth:`.Solution.overwrites()`.
+ ENH(plot): ``Solution`` is also a :class:`.Plottable`; e.g. use ``sol.plot(...).

+ DROP(plot): `executed` arg from plotting; now embedded in `solution`.

+ ENH(PLOT.jupyter,doc): allow to set jupyter graph-styling selectively;
fix instructions for jupyter cell-resizing.

+ fix(plan): time-keeping worked only for sequential execution, not parallel.
Refactor it to happen centrally.

+ enh(NET,.TC): Add PREDICATE argument also for ``compile()``.

+ FEAT(DOC): add GLOSSARY as new :ref:`arch` section, linked from API HEADERS.

=======================================
+ FIX(plan): ``plan.repr()`` was failing on empty plans.
+ fix(site): minor badge fix & landing diagram.

==================================================================================================
+ BREAK/ENH(NETOP): MERGE NESTED NetOps by collecting all their operations
in a single Network; now children netops are not pruned in case
some of their `needs` are unsatisfied.

+ feat(op): support multiple nesting under other netops.

+ BREAK(NETOP): REVERT Unvarying NetOps+base-plan, and narrow Networks instead;
netops were too rigid, code was cumbersome, and could not really pinpoint
the narrowed `needs` always correctly (e.g. when they were also `provides`).

+ A `netop` always narrows its `net` based on given `inputs/outputs`.
This means that the `net` might be a subset of the one constructed out of
the given operations. If you want all nodes, don't specify `needs/provides`.
+ drop 3 :class:`.ExecutionPlan` attributes: ``plan, needs, plan``
+ drop `recompile` flag in ``Network.compute()``.
+ feat(net): new method :meth:`.Network.narrowed()` clones and narrows.
+ ``Network()`` cstor accepts a (cloned) graph to support ``narrowed()`` methods.

+ BREAK/REFACT(OP): simplify hierarchy, make :class:`.Operation` fully abstract,
without name or requirements.

+ enh: make :class:`.FnOp` IMMUTABLE, by inheriting
from class:`.namedtuple`.

+ refact(net): consider as netop `needs` also intermediate data nodes.

+ FEAT(:gg:`1`, net, netop): support pruning based on arbitrary operation attributes
(e.g. assign "colors" to nodes and solve a subset each time).

+ enh(netop): ``repr()`` now counts number of contained operations.

+ refact(netop): rename ``netop.narrow() --> narrowed()``

+ drop(netop): don't topologically-sort sub-networks before merging them;
might change some results, but gives control back to the user to define nets.