(16 Dec 2019, @ankostis): ENDURED Execution

• FEAT(NET): when :func:.set_endure_execution configuration is set to true,
  a :term:netop will keep on calculating solution, skipping any operations
  downstream from failed ones. The :term:solution eventually collects all failures
  in :attr:.Solution.failures.

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

• ENH(plot): mark :term:overwrites, failed & canceled (see :term:endurance).

• refact(conf): fully rename confguration opetion skip_evictions.

• enh(net): improve logging.

(13 Dec 2019, @ankostis): ChainMap Solution for Rewrites, stable TOPOLOGICAL sort

• 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:overwrites,
    • 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:.Plotter; e.g. use ``sol.plot(...)```.

• DROP(plot): executed arg from plotting; now embeded 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.

(12 Dec 2019, @ankostis): bugfix

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

(11 Dec 2019, @ankostis): NESTED merge, revert v3.x Unvarying, immutable OPs, "color" nodes

• 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:.FunctionalOperation IMMUTABLE, by inheriting
    from class:.namedtuple.

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

• FEAT(:gg:1, net, netop): support prunning 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 controll back to the user to define nets.

(6 Dec 2019, @ankostis): cooler ``prune()``

• break/refact(NET): scream on plan.execute() (not net.prune())
  so as calmly solve needs vs provides, based on the given inputs/outputs.
• FIX(ot): was failing when plotting graphs with ops without fn set.
• enh(net): minor fixes on assertions.

(2 Dec 2019, @ankostis): UNVARYING NetOperations, narrowed, API refact

• NetworkOperations:

  • BREAK(NET): RAISE if the graph is UNSOLVABLE for the given needs & provides!
    (see "raises" list of :meth:~.NetworkOperation.compute()).

  • BREAK: :meth:.NetworkOperation.__call__() accepts solution as keyword-args,
    to mimic API of :meth:Operation.__call__(). outputs keyword has been dropped.

    .. Tip::
    Use :meth:.NetworkOperation.compute() when you ask different outputs,
    or set the recompile flag if just different inputs are given.

    Read the next change-items for the new behavior of the ``compute()`` method.
    

  • UNVARYING NetOperations:

    • BREAK: calling method :meth:.NetworkOperation.compute() with a single argument
      is now UNVARYING, meaning that all needs are demaned, and hence,
      all provides are produced, unless the recompile flag is true or outputs asked.

    • BREAK: net-operations behave like regular operations when nested inside another netop,
      and always produce all their provides, or scream if less inputs than needs
      are given.

    • ENH: a newly created or cloned netop can be :meth:~.NetworkOperation.narrow()\ed
      to specific needs & provides, so as not needing to pass outputs on every call
      to :meth:~.NetworkOperation.compute().

    • feat: implemented based on the new "narrowed" :attr:.NetworkOperation.plan attribute.

  • FIX: netop needs are not all optional by default; optionality applied
    only if all underlying operations have a certain need as optional.

  • FEAT: support function **args with 2 new modifiers :class:.vararg & :class:.varargs,
    acting like :class:.optional (but without feeding into underlying functions
    like keywords).

  • BREAK(:gh:12): simplify compose API by turning it from class --> function;
    all args and operations are now given in a single compose() call.

  • REFACT(net, netop): make Network IMMUTABLE by appending all operations together,
    in :class:NetworkOperation constructor.

  • ENH(net): public-size _prune_graph() --> :meth:.Network.prune()`` which can be used to interogate needs&providesfor a given graph. It acceptsNone inputs&outputs` to auto-derrive them.

• FIX(SITE): autodocs API chapter were not generated in at all,
  due to import errors, fixed by using autodoc_mock_imports <http://www.sphinx-doc.org/en/master/usage/extensions/autodoc.html#confval-autodoc_mock_imports>_
  on networkx, pydot & boltons libs.

• enh(op): polite error-,msg when calling an operation with missing needs
  (instead of an abrupt KeyError).

• FEAT(CI): test also on Python-3.8

(24 Nov 2019, @ankostis): Zoomable SVGs & more op jobs

• FEAT(plot): render Zoomable SVGs in jupyter(lab) notebooks.
• break(netop): rename execution-method "sequential" --> None.
• break(netop): move overwrites_collector & method args
  from netop.__call__() --> cstor
• refact(netop): convert remaining **kwargs into named args, tighten up API.

(20 Nov 2019, @ankostis): enhance OPERATIONS & restruct their modules

• REFACT(src): split module nodes.py --> op.py + netop.py and
  move :class:Operation from base.py --> op.py, in order to break cycle
  of base(op) <-- net <-- netop, and keep utils only in base.py.
• ENH(op): allow Operations WITHOUT any NEEDS.
• ENH(op): allow Operation FUNCTIONS to return directly Dictionaries.
• ENH(op): validate function Results against operation provides;
  jetsam now includes results variables: results_fn & results_op.
• 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,
  because it allowed too wide args, and offered no help to the user.
• REFACT(configs): privatize :data:network._execution_configs; expose more
  config-methods from base package.

(12 Nov 2019): global configs

• BREAK: drop Python-3.6 compatibility.
• FEAT: Use (possibly multiple) global configurations for all networks,
  stored in a :class:contextvars.ContextVar.
• ENH/BREAK: Use a (possibly) single execution_pool in global-configs.
• feat: add abort flag in global-configs.
• feat: add skip_evictions flag in global-configs.

(20 Oct 2019): DROP BW-compatible, Restruct modules/API, Plan perfect evictions

The first non pre-release for 2.x train.

• BRAKE API: DROP Operation's params - use funtools.partial() instead.

• BRAKE API: DROP Backward-Compatible Data & Operation classes,

• BRAKE: DROP Pickle workarounds - expected to use dill instead.

• break(jetsam): drop "graphtik_` prefix from annotated attribute

• ENH(op): now operation() supported the "builder pattern" with
  :meth:.operation.withset().

• REFACT: renamed internal package functional --> nodes and moved classes around,
  to break cycles easier, (base works as suppposed to), not to import early everything,
  but to fail plot early if pydot dependency missing.

• REFACT: move PLAN and compute() up, from Network --> NetworkOperation.

• ENH(NET): new PLAN BULDING algorithm produces PERFECT EVICTIONS,
  that is, it gradually eliminates from the solution all non-asked outputs.

  • enh: pruning now cleans isolated data.
  • enh: eviction-instructions are inserted due to two different conditions:
    once for unneeded data in the past, and another for unused produced data
    (those not belonging typo the pruned dag).
  • enh: discard immediately irrelevant inputs.

• ENH(net): changed results, now unrelated inputs are not included in solution.

• refact(sideffect): store them as node-attributes in DAG, fix their combination
  with pinning & eviction.

• fix(parallel): eviction was not working due to a typo 65 commits back!