►
C
A
A
So
we
turn
this
data
flow
into
we
overrelate
into
a
dict,
and
then
we
say
data
flow
as
dict
and
then
we
grab
all
of
the
data
flows
which
are
produced
and
when
we're
done
with
that,
we
grab.
A
A
A
Maybe
even
default
installed
all
right,
so
we
should
really
only
pass
the
data
types
that
are
supposed
to
be
passed
and
then
let
the
overlays
figure
out
the
rest
of
it
because
we
shouldn't
be
adding
in
you
know
a
bunch
of
functional
behavior
with
the
data
without
ensuring
that
it
happens
in
the
data
flow.
A
Okay,
so
if
we
wanted
to
so,
we
would
just
pass
data
fast
deck.
A
A
When
creating
data
flow
as
class
methods,
question
mark
all
right.
So
maybe
when
we
do
our
data
flows
class
and
we
do
the
like
the
synthesis
to
the
dataflow
class,
we
apply
overlays
which
mean
that
the
resulting
data
flows
class-
that's
created,
you
know,
runs
a
data
flow
which
will
do.
D
A
Passing
values
right,
but
it
will
still
get
the
visibility
that
it's
happening
so.
B
A
So,
okay,
so
dataflowstick
definition,
data
file,
okay,
so
grab
that
okay,
so
take
the
dataflow
to
be
overlaid.
Turn
it
into
a
dictionary,
merge
all
the
other
data
flows
into
it
and
then
so
merge
took
the
data
flow
turn
it
into
a
dictionary.
The
input
data
flow
merge
all
the
other
data
flows
that
were
created
into
it
by
the
other
output
by
the
other
overlays
that
run
and
then
grab
that
grab.
That.
E
C
C
A
Basically,
grab
you
know
whatever
any
the
this.
This
operation
says:
hey,
run,
git
single
right
and
tell
git
single
to
grab
me
the
alice
version,
the
the
definition
that
says
alice
version,
any
values
by
that
or
one
value
by
that,
because
it's
get
single
and
so
there's
only
one
value
in
there.
It's
this
one,
which
we
just
added
as
an
input
and
we're
just
going
to
grab
that
out
right.
So.
C
A
All
right,
so
this
is
for
the
you
know,
non-python
3.9
and
before
compatibility
layer
we
have
to
import
lib
metadata
as
a
slightly
different
situation
here,
input
metadata.
B
A
Top
level
flow,
okay,
always
if
running
frame
within
another
flow
as
a
subflow,
always
use
parent
overlays.
When
creating
a
new
data
flow,
so
we
should
modify,
we
should
modify,
run
data
flow
or
subflow
or
whatever.
A
All
right,
we
can
also
grab.
C
A
C
E
C
A
A
A
So
default
here
we
go.
A
A
A
We
want
to
this
looks
right
now.
This
data
flow
looks
correct.
Okay,
so
we
want
to
take
the
data
flows
to
be
overlaid.
We
want
to
put
them
as
data
flow
as
dict.
We
want
to
merge
them
all
together.
Finally,
once
they're
merged
all
together,
we
want
to
grab
them
and
output
them
as
overlaid.
Okay,
so
apply.
A
E
C
C
A
A
A
C
A
A
Okay,
there
we
go
now
we
fixed
our
problem
of
not
not
sure
whether
we
should
pass
the
orchestra
or
not.
We
know
that
we
have
to
pass
the
orchestrator,
because
if
we
don't,
we
end
up
with
a
circular
reference,
so
to
run
so,
let's
pass
the
orchestrator
right.
So
we
can
now
have
data
flow
to
be
overlaid,
data
flow
will
be
overlaid,
dead
flow
is
ticked,
okay
goes
through.
There
goes
through
merge,
okay,.
C
D
B
A
A
dick's
not
a
data
flow
okay,
so
I
think
it's
because
this
configs
okay,
so
we
have
an
issue
with
configs
right
now,
where,
let's
see
so
df
df
base.
Okay,.
A
All
right
so
remap
config,
so
re
mac,
remap
config
has
this
data
flow
parameter,
so
config
config
dict,
okay.
So
we
call
from
dict
let's
step
into
from
dict.
A
A
Do
not
convert
already.
A
C
B
A
A
A
Okay,
there's
co
routine.
Here,
okay
uses
self.
This
is
our
wrapping
around
functions.
This
is
a
little
bit
needs
to
be
changed,
so
results
return.
None
auto,
def,
outputs,
okay,
so
auto
def
outputs
equals
true,
so
single
output,
non-dict,
okay,
so
single
output,
nondict.
A
A
A
Okay,
so
support
operation
defined.
A
Okay,
so
I'm
actually
going
to
name
this
dict
output,
we'll
set
dict
output
to
true
by
default,
because
that's
what
we
currently
have
and
then
we
can
slowly
migrate,
so
it
dict
up.
So
if
dict
output
is
true.
E
A
A
A
A
A
Okay,
so
this
thing
now,
if
we
were
doing
this
anymore
yeah,
so
basically
we're
this
is
coming
from
the
teleport
scope.
A
A
A
D
A
Df
base
up
multi
right
so
allow
for
there's
an
issue
for
this.
I'm
not
sure
what
it
is.
A
E
A
So
at
a
minimum
we
need
to
merge
with
one
flow,
which
is
a
blank
flow
right.
So
basically,
this
will
ensure
adding
a
blank
flow
ensures
if
there
are
no
other
overlays.
We
just
end
up
merging
with
the
input
overlay
with
a
blank
overlay
resultant
and
the
input
data
flow,
resulting
in.
A
So
we'll
get
that
one
another.
Just
data
flow
oops,
there's
a
list.
A
A
A
B
A
A
A
C
A
C
A
Okay,
so
we
dropped
into
the
debugger.
Where
are
we
so
we're
in
run
operations
for
ctx
and
operations
for
ctx
and
operations
for
ctx?
It
looks
like
we're
in
remap,
okay,
so
man,
cli,
do
run.
Overlay
default,
run,
run
operations
for
ccs
run,
node
retry
runner
remap
run
operations,
which
is
for
ctx,
so.
A
A
High
level,
so
this
patch
is
high
level
overlay,
call
async
methods,
passing
orchestrator.
B
A
A
B
E
A
You
can't
type
him
to
land
this
one:
that's
bummer,
okay,
multi-output,
false,
okay,.
A
Okay,
note.
A
It
will
create
a
name
of
the
same,
so
maybe
we
should
just
go
through
and
actually
say.
C
E
A
E
A
D
C
A
Okay
change.
C
A
A
A
All
right
so,
let's
add
an
output
stage
operation
so
flow
from
dict
right.
A
Flow
right,
which
is
the
merged-
maybe
let's
call
it
merged.
A
B
A
D
A
A
A
A
A
A
I
think
this
code
already
went
and
found
its
merry
way
into
other
places.
So
that's
not
good.
E
A
D
D
A
B
A
So
this
is
still
giving
us
trouble
here,
so
this
is
creating.
C
A
Okay,
there
we
go
so
that's
correct
see,
so
it
is
this
watch.
If
you
remove
that
continue
statement,
it
blows
up
there.
You
go
so
what's
happening
here,
so
field
modifications
items
set
after
key
key
to
modify
value
to
use
fields
field.
So
this
field,
these
fields
that
are
coming
from
inner
source
class
config,
which
are
just
a
copy
of
our
serial
mic,
commands
with
a
different
data
flow
spit
in
by
default
for
the
diagram
command.
The
problem
is
that
that's
actually
affecting
the
class
variable
for
the
diagram
command
it's
actually
affecting.
A
So
the
problem
is
when
we
create
this
new
diagram
command
for
the
you
know.
What's
basically
the
should
I
operations
plus
a
little
more
for
this
inner
source
operations?
B
A
A
A
A
A
All
right,
so
this
is
the
original
class
config
we
go
through
each
of
the
fields.
We
create
a
new
one
copy
dot
deep
copy.
Maybe
we
copy
the
field
individually,
all
right,
mapping
proxy
object.
This
is
not
good.
Deep
copy
cannot.