►
A
A
Okay
examples,
http
data
deployment
or
dataflow
http
deployment,
so
here
we
combine
the
should
I
cli
metastatic
analysis
tool,
which
is
obviously
going
to
look
very
familiar
to
what
we
just
did.
We
took
the
cli
of
it
right
so
in
this
in
this
demo.
In
this
example,
we
export
the
data
flow
to
a
serializable
representation,
which
is,
I
believe,
that
we
dump
it
to
json,
and
then
we
import
it
via
the
http
api,
because
you
know
we
can
run
data
flows
wherever
so.
A
The
point
is
we're
going
to
run
it
over
http
right
because
we
might
have
something
that
wants
to
access
it
over
http.
So
the
http
data
api
is
going
to
pick
up
the
data
flow.
It's
going
to
run
it
it's
going
to
produce
these
outputs
all
right,
okay.
So
now
what?
If
we
want
to
use
our
lines
of
code
by
language
lines
of
code
comments?
What
if
we
want
to
use
those
get
feature
operations
with
with
the
rest
of
it?
Well,
then
we
create
an
overlay
right,
and
so
what
really
is
an
overlay?
A
Well,
I
think
we
can
think
of
an
overlay
almost
like
oh
override
overlay.
Let's
call
it
an
overlay,
I
think
overlay
is
probably
better.
We
should
rename
it
to
from
override
to
overlay,
so
an
overlay
would
enable
you
to
override
something
right.
So
an
overlay
is
basically
going
to
be
a
data
flow
which
we
run,
one
which
we
execute
and
when
we
execute
the
data
flow,
it's
going
to
be
like
okay,
apply
organizational
policies
right.
A
Okay,
so
if
you
are
familiar
with
elixir,
this
is
going
to
be
sort
of
like
your
supervisors
right
and,
if
you've
been
following
the
thread.
This
is
your
strategic
plans
right,
and
this
also
may
be.
You
know
additional
feature
extraction
stuff.
So,
let's
get
at
it.
So
what
are
we
going
to
do
so
similar
to
the
dffml?
Where
are
we
pwd,
okay,
so
similar
to
the
cli
cli?
A
So
if
we
look
at
the
dfml
cli,
we
will
see
the
services
in
points
right,
so
this
services
command
right
so
same
thing
that
we
were
used
to
last
time.
Okay,
so
if
we
set
something
here,
it'll
become
it'll,
basically
say:
okay,
well,
is
it
a
command
class
right?
The
util
command
stuff,
we'll
say,
is
a
command
class.
If
it's
command
class,
I'm
going
to
add
it
as
a
sub
parser
right,
then
you're
going
to
be
able
to
access
it.
So
basically,
you
know
this
code
here,
dfml
service,
different
service.
A
So
if
we
say
df
mouse
service,
it's
going
to
load
any
service
entry
points
that
we
have
right,
and
so
we
can
also
use
our
dffml
service
so
within
those
services
right.
So
these
are
things
that
basically
we're
going
to
extend
off
of
the
dfml
api
as
sort
of
like
hey.
You
know
this
definitely
hooks
into
dffml.
It's
a
dfml
service
right.
So
obviously
so
alice
is,
you
know
the
inner
source
stuff.
A
A
So
this
is
going
to
be.
This
is
a
debug
command
that
we
have
as
a
part
of
the
development
service
right,
and
so,
where
is
the
development
service?
Well,
it's
installed
in
the
git
repository
whose
route
is
here
or
wait:
no
okay.
So
this
is
the
package.
The
root
of
the
package
is
here.
This
is
the
installed
version
and
this
is
the
installed
version
of
the
inner
source
operations
right.
A
So
this
is
going
to
list
all
the
entry
points
if
you're
familiar
with
the
python
entry
point
ecosystem
or
the
entry
point
plug-in
system.
So
there's
there's
a
bunch
of
links,
I'm
not
going
to
cover
it
right
now,
okay,
so
what
do
we
want
to
do?
Well,
we
want
to
leverage
this
type
of
thing
and
what
we
want
to
do
is
we
want
to
load.
So
this
is
a.
This
is
a
slightly
different
implementation
of
our
regular
plug-in
stuff,
and
I
think
it
is
because
it's
gonna
it's.
A
This
runs
no
matter
what
on
load,
so
we
have
to
have
some
special
error
handling
around
it,
because
if
I
run
any
dffml
command,
it's
going
to
end
up
trying
to
load
the
the
different
services,
and
if
you
have
one
installed,
for
example,
that
doesn't
maybe
your
api
diverge
and
you
forgot
to
uninstall
it
now.
Your
command
line
is
going
to
crash
right.
So
we're
just
going
to
report
we're
going
to
report
errors
and
that's
what
that
accept
is
about.
So
what
do
we
want
to
do?
A
A
So
I
believe
there
was
some
kind
of
there.
It
is
okay
load
dataflow
from
config
loader,
so
we
added
this
pretty
recently
and
what
is
this
so
this
is
going
to
be
a
little
helper
function
for
us,
which
is
going
to
basically
take
either
a
path.
If,
if
something
is
already
a
data
flow,
it's
just
going
to
return
the
data
flow.
If
it's
a
path,
it's
going
to
use
the
correct,
config
loader
right,
which
is
going
to
be
by
extension.
A
We
also
talked
about
protocol
in
here
in
the
to
do,
and
it's
going
to
load
that
it's
going
to
load
that
data
flow
right,
and
this
is
probably
something
that
needs
to
change
right.
I
don't
think
that
this
is.
This,
doesn't
look
right
to
me.
It
just
doesn't
look
right.
I
don't
know
what
we're
gonna
do
about
this.
This
is
sort
of.
I
think
this
is,
I
think,
no.
I
think
I
think
I
think
I
think
this
is
solved
by
the
strategic
plans
yeah.
A
This
is
solved
by
the
strategic
plans,
basically
suggesting
further
feature
extraction
and
we'll
go
we'll
we'll
basically
use
that
right.
So
we'll
say:
okay,
if
you
see
a
path
right
and
it's
in
the
usage
of
a
is
in
the
context
of
this
thing-
is
a
type
which
is
dataflow,
then
go
try
to
load
it
via
these
mechanisms
right
and
you're,
going
to
provide
it.
We'll
provide
a
data
flow
for
that
right.
Okay,
so
load
data
from
the
load
dataflow
from
config
loader.
A
We
don't
have
to
pass
it
a
config
loader
class,
but
if
we
do,
then
each
subsequent
data
flow
that
we
load
is
going
to
reuse
the
same
config
loader
and
then
just
give
us
a
little
bit
of
a
performance
increase
right
because
we're
not
reinstantiating
objects.
So
all
right.
So
what
do
we
want
to
do
organizational
policies?
Okay,
so
via
overlays
all
right?
So
let
us.
A
Organizational
policies
via
overlays
we're
going
to
load
them
like
services
and
then,
when
we
call
this
load
data
flow
from
config
loader
all
right,
so
we're
going
we're
going
to
need
to
identify
the
places
where
this
load
data
load
data
flow
from
config
loader
is
not
used.
Okay.
So
what
we're
really
going
to
need
to
do
is
for
now
we're
going
to
load
overlays
via
this
thing
see,
let's
actually
see,
let's
just
let's,
let's
go!
Look
at.
Let's
go!
Look
at!
Let's
go!
Look
at
the
run
command.
Let's
go
look
at
the
run
command.
A
So
the
run
command
could
be
a
great
place
for
us
to
do
this,
so
here
yeah.
Maybe
let's
just
do
this
in
the
run
command
right.
So
let's
go
ahead
and
say
so.
This
thing
should
have
already
taken
a
data
flow
right,
so
dfml
util
internal
right,
so
it
should
have
already
taken
a
data
flow
or,
let's
say,
let's
grab
cli
data
flow
right,
so
it
should
already
take
a
data
flow.
A
A
B
A
A
Eventually,
it'll
be
the
system
context
right,
which
we'll
need
inputs
and
all
our
list
for
okay
orchestrator.
We
are
going
to
I'd
like
to
do
rework
once
we
have
system
context
for
over
run
overlay
system
context
and
remember.
The
system.
Context
is
basically
like
the
arguments
to
this
thing
as
a
data
structure,
so
it'll
have
its
own
orchestrator.
B
B
A
A
B
A
A
B
A
A
All
right,
so
we
recursively
call
run.
So
if
there
is
an
overlay
we
recursively
call
run,
we
call
run
passing
the
oversee
overlay.
We
added
to
do
saying
later,
we'll
run
from
the
system
context
where
the
overlay
will
be
a
system
context
and
overlay,
not
none
and
is
instance.
Okay,
we're
not
gonna.
Do
that,
because
then
then
we
just
had
a
bug
like
this,
where
we
had
input
validation
and
then
we
changed
something
and
then
yeah,
so
infinite
validation,
good,
but
still
in
flux,
api
right.
So,
okay,.
A
So
what
did
we
say?
Well
run
the
overlay
grab,
the
whatever,
whatever
your
output
just
give
me,
the
you
know
just
give
me
the
data
flow
right
so
and
the
results
will,
it
should
say,
overlaid
right.
That
should
be
the
key
value
pair
within
the
results
of
the
data
flow
right.
So
overlay
is
not
none
all
right,
so
if
overlay
is
not
done
all
right,
okay,
so
when
we
run
this
thing,
so
when
we
run
this
thing,
overlay
is
not
done.
B
A
Okay,
so
we're
going
to
make
it
so
that
if
you
have
installed
packages,
they
are
going
to
overlay
by
default,
unless
you
tell
them
specifically
not
to
right.
So
if
you
provide
an
overlay,
so
if
you
provide
an
overlay,
it
will
use
that
overlay
and
it
will
assume
that
you
have
correctly
grabbed
organizational
overlays
in
your
creation
of
your
of
your
overlay
right.
A
Okay,
so
that's
gonna
be
very
important.
We're
gonna
have
to
have
some
audit
functionality
around
that
and
if
there
is
no
overlay
we're
going
to
determine
whether
we
need
an
organizational
overlay-
and
we
do
that
so
to
determine
audit
sum
method
to
audit
if
org
overlays
were
or
taken
into
account
if
overlay
past
within.
A
Okay,
so
assume
we
have,
let's
assume
so,
load
org
overlay.
So
it's
not
none.
So
if
overlay
is
none
load,
org
load
installed
overlays
if
present,
okay.
So
what
are
we
going
to
do?
What
are
we
going
to
do?
What
are
we
going
to
do
so
we're
going
to
build
a
data
flow
where
we
we're
going
to
build
a
data
flow
where
we
so
we're
going
to
load
all
org
installed,
overlays
we're
going
to
build
a
data
flow
which
is
run
subflow
for
each
one
of
them.
A
I
can
do
this:
okay,
okay,
oh
okay!
This
is
fine,
we're
just
gonna
overlay
them
all
on
each
other.
Okay,
this
is
fine,
okay.
So,
let's,
how
do
we
do
that?
This
is
great.
Okay,
so
merge
great
okay,
we're
just
gonna
call
dataflow,
merge
boop,
all
right,
so
we're
just
gonna
overlay.
Every
data
flow.
That
is
a
so
let's
see,
read
dfml.
A
B
A
A
A
Okay,
so
iterate
all
of
over
the
all
the
installed
overlays
merge
them
together
into
one
make
that
the
overlay.
So
basically,
if
we're
not
given
an
overlay,
let's
grab
all
the
installed
ones,
merge
them
all
together,
create
the
the
the
top
level
overlay
and
then
we're
going
to
you
know,
produce
this
output.
So
if
the.
A
Each
overlay
could
accept
the
data
flow
right
and
when
it
accepts
the
data,
so
then
it
and
then
it
could
you
know
and
and
when
it
accepted
it.
So
subsequent
overlay
could
say
that
the
that
it
should
link
together.
You
know
the
previous
overlay
in
some
way
right,
so
we're
gonna
need
some
kind
of.
I
wonder:
there's
there's
probably
something
that
we'll
need
to
do
so
to
do.
You
know
to.
A
A
A
All
right
so
we're
going
to
write
our
first
overlay
and
that
overlay
is
going
to
be
for
dfml
itself.
So
what
is
a
good
example
of
this?
So,
let's
jump
in
so
so
any
of
the
different
plugins.
So
let's
jump
into
df.
What's
a
good
one,
I
think
we
did
tuner
recently
yeah.
So
let's
go
ahead
and
copy
tuner,
so
cpr
dfml
tuner.
B
A
A
B
B
B
B
A
A
A
B
A
B
A
Right
so
then,
when
we
call
load,
that
means
we're
going
to
grab
this
object.
It's
going
to
grab
this
object
out
of
that
file
and
it's
going
to
then
export
it
and
and
and
overlay
it
over
this.
You
know
this
merged,
which
is
basically
just
you
know.
This
is
going
to
be
everything
so,
basically
anything
that's
listed
under
dfml
overlay
within
an
install
package,
you're
going
to
get
merged
in
one
overflow
lead
that
overlay
is
going
to
get
run.