►
A
Okay,
okay,
so
we
found
out,
we
didn't
need
primitive.
We
just
specced
out
this
inner.
A
A
A
D
A
So
if
this
isn't
a
definition,
it's
a
picking
up
area
okay.
So
if
this
isn't
a
definition.
B
A
A
Okay,
so
this
would
be
to
do
or
let's
see
so.
This
is
basically
anything
of
this
type
or
anything
with
definitions.
C
B
A
A
B
E
A
And
stir
I
in
the
case
that
I
is
an
integer
when
we're
iterating
over
the
conditions.
However,
if
we're
iterating
over
the
conditions.
C
E
A
A
C
E
B
A
A
All
right,
let's
check
it
out.
Okay,
what
do
we
got
so
unhash
will
type
list?
Oh,
it
doesn't
like
the
links.
Okay,.
A
Let's
see
it
doesn't
like
the
links,
so
let's
go
links
where
you're
at
list
tuple.
E
B
A
A
So
we
should
serialize
to
the
ids
the
definition.
C
C
A
Type
dick
links
well,
it
only
needs
the
first
link
right,
so
we
shouldn't
go
all
the
way
down:
link
dot,
uid
four
link
and
exported
links.
B
D
C
A
A
Then
you're
tuple,
two,
then
congratulations!
So
what
happens
to
uncooperative
data
types?
They
become
a
tuple
okay,.
A
Okay,
you're
all
a
tuple.
Now,
congratulations,
you're,
a
hashable
data
type.
A
C
D
B
C
C
A
Okay,
so
we're
going
for
fastest
path
to
get
the
system
context
running,
and
why
did
we
have
to
do
the
primitive
changes
because
we're
playing
with
making?
We
also
want
to
do
the
syntax
changes
as
well,
which
means.
B
A
E
E
E
A
A
If
you
went
wish
to
instantiate
a
definition
in
a
synchronous
environment,
you
need
to
have
the
links
already
resolved.
If
you
wish
to
execute
a
definition
d
serialization
in
an
asynchronous
environment,
then
you
don't
have
to
have
the
links
resolved
already
right,
you
can.
You
can
lazily
resolve
them.
A
E
A
So
here
we
do
a
trick.
We
say.
D
A
The
basically
we're
deserializing
a
data
class
in
this
function
and
if
we
detect
that
the
data
class
or
that
the
dictionary
which
we
are
deserializing,
the
data
class
for
is
of
has
this
plug-in
config
syntax,
then
we're
going
to
treat
the
the
plug-in
as
a
base
configurable,
that's
the
convert
value
so
load
that
basically
ends
up
being
an
entry
point.load
for
the
the
the
value
being
the
plug-in
and
then
basically
we
we
pass
the
then
we
we
pass
all
the
config
values
as
they
they
configure
the
plug-in
and
we
instantiate
that
plug-in.
B
A
Not
clean
right
so
not
clean,
should
we
copy
it.
A
So
what
I'm
thinking
is
this
could
be
a
nice
little
place
for
us
to
do
some
like
like
introduce
this
temporary
area
for
this
code
change
right.
So
we're
going
to
do
a
code
change
right
and
we
know
that
we
have
to
we're
going
to
do
a
code
change.
This
is
still
working
youtube.
That
youtube
is
still
working.
Can
you
see
me
all
right,
yeah,
okay,
great,
so
so
we're
going
to
do
a
code
change
right.
Our
code
change
is
we're
adding
these
links
to
the
the
what's.
A
It
called
the
definition
we
would
like
windy
serializing
to
be
able
to
resolve
links.
Similarly
to
the
data
flow
right
now
we
can
add
a
context
structure
or
we
can
effectively
say
if
you
attempt
to
deserialize
a
dictionary
which,
with
different
keys
to
the
ones
that
you're
used
to
right,
then
treat
some
of
those
keys
as
your
lookup
table
for
your
other
link,
uids
right,
the
unique
identifiers,
so
that
seems
like
it
would
work
for
our
use
case
right
now,
and
I
think
we
might
just
go
with
that.
A
A
Oh
there,
it
is
see
there
there
it
is
it
doesn't
matter
what
you
do
if
I'm
explicitly
setting
it
doesn't
matter
what
we
did
other
places
if
we
explicitly
set
the
type
to
be
a
list
there,
so
we'll
just
change
these
god.
I
got
that
okay.
A
Once
again,
this
is
hax
hex
hacks,
but
I
mean
this
is
it's
like
a.
A
167.,
okay
from
dict
on
data
flow
requires
another
parameter.
That
really
surprises
me.
Did
we
throw
that
in
somewhere
from
dick?
Did
I
save
that
context
thing?
I
don't
remember
that
what
happened
to
that?
Let's
see,
let's
see,
let's
see,
where's
data
flow
from
dict
all
right.
Okay,
here
we
are
data
flow
from
dick
takes
one
positional
argument:
two
were
given.
A
C
A
E
E
C
A
A
Oh
kw
args,
oh
so
we
have
to
do
an
expansion,
so
we're
just
missing
the
star
star
right.
So
if
we
star
star,
then
it's
gonna
splat
and
it's
gonna
merge
it's
gonna.
It's
not
gonna,
merge!
It's
gonna,
take
the
merge
flow
and.
A
A
A
Oh
that
stressed
me
out.
Okay,
I
hope
everything's.
Okay,
we
just
did
a
lot
of
weird
stuff.
Okay,
let's
try
to
save
some
of
that
before
we
get
more
confused
here
about
what
just
happened.
A
Okay,
so
what
happened
here?
Is
this
related?
No,
is
this
related?
No,
is
this
related?
No.
Is
this
related?
Yes,
is
this
related?
Yes,
yes,
question!
Mark!
Yes,
yes
is
this
related
e?
We
want
to
edit
this
one
because
we
don't
want
to
add
this
right
now,
but
we
do
want
to
add
that
we
do
want
to
add
this
links.
A
These
are
two
unrelated
things.
Oh
okay
is
links
related
to
the
definition
stuff.
No
links
is
not
related
to
the
definition
stuff.
B
A
A
This
is
fixing
up
definition,
stuff
and
links
that
looks
like
we
shouldn't.
Should
we
commit
this
here
yeah.
This
is
just
a
formatting
change,
let's
edit
it.
So
let's
not
add
that.
Let's
not
add
that,
let's
not
add
that
right
so
don't
add
the
the
bits
that
were
just
so.
This
is
just
a
formatting
change
right,
quit.
A
Okay,
this
is
not
something
that
we
want
to
add
to
get.
This
is
not
something
that's
related
to
definitions,
not
related
to
definitions.
Remember
we're
doing
definitions
right
now,
not
related
to
definitions,
entirely,
two
related
to
overlays,
two
related
to
command
structures.
A
No,
no
system,
context
stuff
that
is
related
to
the
command
stuff
overlay
stuff.
This
is
alice,
there's
more
alice.
I
don't
need
that.
Don't
need
that!
Don't
need
that
right.
Now,
okay,.
A
A
So
what
does
this
get
this
staged?
So
what
are
we
doing
here?
So
we
are
fixing
up
brand
annotations
that
are
classes
and
ensuring
the
correct
name
gets
used.
A
A
Links
hackie
initial
support
for
links
produces
verbose,
duplicate
information
instead
of
referencing.
A
Patching
considered
patching
from
dick,
I
like
that
idea
actually
from
our
definition.
A
To
support
config
dot
from
dick
style
conf
is
config
dict
check
to
determine
if
we
should
deserialize
and
reference
links
found
within
specialized.
A
Conden
or
config
or
addict
representation
d
serialize
is
not
the
right
word
that
implies
that
there's
a
format
involved.
This
is
really
just
a
data
structure.
Reference
links
found
within
specialized
ticked
representation
check
to
determine
if
we
should
decentralize
the
reference
link
found
with
the
specialized
dict
representation
for
to
facilitate
to
facilitate,
facilitate
synchronous.
E
D
A
Of
a
link
of
linked
of
reconstruction,
of
links
without
duplication
of
definition,
linked
linked,
linked
definition,
linked
definition,
data
similar
to
data
flow
dot
linked
okay.
So
I
actually
like
this
more
and
more
the
more
I
think
about
it.
So
recording
I
think
that's
a
it's
it's!
I
think
it's
interesting,
so
what
I
think.
I
think
that
that
that
we
should
seriously
consider
doing
more
messing
around
with
that.
So
that
concept,
what
time
is
it
58?
A
So
what
let's
say
about
what
is
it
question
mark
t
equals
50.
so.
A
So
50
times,
60,
okay,
so
3
000.-
is
that
right,
3
000
seconds
in
that
doesn't
seem
right.
I'm
60
times
60
60
seconds
times,
50
minutes,
3000
seconds,
sure.
A
A
179
179
at
config,
if
not
installed,
overlays
config,
I
don't
think
we
need
do.
We
need
this.
If
not
don't
release
config?
No,
we
don't
need
that.
We
just
need
this
dfml
installed
overlays,
which
is
our
first
config
class
yay
default
factory
for
subclass
default
factory
for
subclass.
Let's
just
say,
subclass.
A
Get
crap
dash
c
or
dash
b
or
dash
a
10,
def,
subclass,
stuff,
backslash,
space,
subclass,
okay,
so
a
40.
or
60
okay.
So
this
is
in
with
dfml
utils
cli
command,
but
this
really
could
be
in
any
base.
Data
flow
facilitator
object,
so
let's
go
ahead
and
actually
throw
this
into
the
base.
Dataflow
facilitator
object,
which
I
believe
command
derives
from.
A
So
where
is
that
so
that
is,
I
thought
we
had
a
window
open
for
that.
A
C
A
A
So
if
we
throw
it
on,
no,
let's
not
throw
it
on
there.
So,
let's
throw
it
on.
A
A
Config-
let's
just
throw
it
on
here-
why
not?
What
if
you
wanted
to
what,
if
you
wanted
to
do
it
this
way,
maybe
you
do
maybe
we
provide
too
many
options.
Let's
see,
let's
see
so,
okay,
so
diagram
that
should
get
this
example
should
still
be
the
same.
We
just
need
to
make
sure
replace.
Config
is
around
here
there.
It
is.
A
A
D
A
A
Explicit
is
better
than
implicit
okay,
so
these
base
data
look
at
there.
It
is,
and
there
it
is
here
we
are
okay.
What
is
this?
This
is
not
once
again,
this
is
dump
discussion,
dfml
system
context,
system,
context,
okay,
system
context.
Here
we
are
the
system.
Context
is
the
upstream
overlay
and
the
orchestrator
we
can
use
it
to
represent
the
past
present
and
the
future
so,
and
our
synchronization
between
states
and
time
so
via
the
application
of
the
overlays
to
the
upstream
so
base
data
flow,
facilitator,
object.
Context
is
not
defined
there.
A
It
is,
let's
define
it,
let's
pull
it
on
in
base
replace
config,
and
I
assume
you'll
be
wanting
the
version
without
context
as
well.
Okay,
let's
run
formatter
on
that.
Okay,
add
config.
Let's
make
sure
we
import
config,
we'll
probably
want
field
two.
Do
we
want
field?
Okay,
yeah?
We
do
want
field
because
we
should
go
describe
these
things
all
right,
so
we
should
say
field
the
system,
context
which
this
one
is
a
derivative
or
which
this
one
was
created
due
to
extremely
overlaying
orchestrator.
A
A
A
And
the
system
context,
which
will
whose
default
flow
will
be
used
for
orchestration,
used
to
yield
an
orchestrator
which
will
be
used
to
which
will
be
used
to
produce
an
orchestrator
which
will
be
used
to
execute
this
system
context.
This
system
context,
including
application
of
overlays.
A
Okay,
so
when
we
execute
the
system
context
to
apply
overlays,
how
should
we,
let's
see?
How
should
we
allow
for
okay?
A
So
we
want
to
execute
the
system
context
using
the
orchestrator
provided
via
execution
of
the
default
method
of
the
system
context
provided
for
the
orchestrator
we're
going
to
do
a
quick
little
hack
here
where
we're
just
basically
going
to
say,
hey.
If
you
gave
me
an
orchestrator
right
out
the
bat
I'm
not
even
going
to
bother
executing
the
system
context,
I'm
just
going
to
use
the
extruder
that
he
gave
me.
A
I
think
I
think
that's
what
we're
going
to
end
up
doing
here,
I'm
not
exactly
sure
yet,
but
you
know
time
check
so
yeah.
That's
probably
what
we're
going
to
end
up
doing
so
system
contact.
A
Okay,
okay,
so
when
we
execute
it,
so
if
we
wanted
to
execute
with
a
different
orchestrator,
when
we
actually
go
to
run
the
data
flow
itself,
we
could
put,
we
could
yield
or
we
could.
We
could
return
from
the
overlay
application
instead
of
returning
to
flow
it's
or
the
the
meshed
system.
Context.
Let's
see
so
we
take
the
upstream.
We
when
we
combine
it
with
the
and
we
use
we
pass.
We
combine
all
the
overlays,
we
run
the
overlay
which
combines
all
the
loaded
overlays,
which
then
runs
the
upstream.
A
A
A
So
maybe
we
have.
For
example,
we
could,
for
example,
install
a
default
overlay
which
basically
will
run
on
any
system
context
which
is
loaded
on
a
system
and
say
hey.
You
know
if
the
resource
usage
looks
like
this
system
doesn't
have
enough.
You
know.
Maybe
this
system
that
you
happen
to
load
on
is
I
we're.
A
We
know
we
have
a
lot
of
iot
devices,
and
so
when
we
deploy
our
when
we
do
an
edge
deployment
and
we're
going
to
ensure
that
the
s
this
the
spins
of
our
software
getting
deployed
to
these
iot
devices
are
going
to
have
this
overlay
pre-installed,
which
will
run
every
single
time
right.
A
new
system
context
is
executed
and
it
might
say,
hey
for
the
orchestrator.
A
Why
don't
you
actually
before
you
return
the
system
or
basically,
okay?
So
basically
the
overlay
this
installed
overlay?
Would
it
would
make
sure
that
the
data
flow
that
gets
returned
is
a.
D
A
Uses
an
orchestrator
that
has
an
operation
implementation
network
which
has
been
configured
using.
You
know,
whatever
attestation
that
happened
at
testation
flows
that
happened
within
the
overlay
to
connect
to
a
edge
server
right,
so
deployment
becomes
trivial,
basically,
so,
okay,
so,
let's
see:
where
are
we?
What
are
we
doing?
A
E
A
Okay,
414
or
214.
load
default
deployment
environment
is
not
defined,
okay
set
and
u
load
default
deployment,
environment,
okay,
so
load
default
deployment
environment.
What
happened
to
that
underscore
class
that
we
had?
I
think
it
got
lost
in
overlay.
Didn't
it?
Where
are
you?
A
Okay,
okay
looks,
like
overlay
overlay,
says,
load
default
so
that
didn't
get
changed
so
we'll
change
that
in
overlay
we
did
change
it
here
in
the
system.
Context.
Okay,
so
we'll
grab
these
guys,
we'll
create
our
little.
What
is
this
thing
called?
It's
the
data
classes.
Library
will
tell
you,
I'm
not
sure
what
it
is.
Sentinel
sentinel
doesn't
sound
right.
It
sounds
right,
but
it
doesn't
sound
right
all
right:
okay,
okay,.
A
A
Okay,
alice
is
not
defined.
Yes,
we're
working
on
it.
Working
on
that
one,
that's
the
point:
okay
smells
good,
let's
see,
alice
is
not
defined,
alice
is
not
defined.
Alice
is
not
defined
all
right.
I'm
happy
with
that
right
now,
not
because
alice
is
not
fine,
but
because
that's
where
we
should
be
at
so
open
architecture
is
not
defined.
Also
working
on
that
one.
Thank
you
very
much.
Stacktrace.
A
System
context,
initial
initial
scratch.
A
Code,
our
initial,
let's
see
plugin
type.
A
A
Always
staged
always
inspect
before
you
commit
always
do
status
and
staged
okay,
I
didn't
do
status,
but
always
do
it
base.
Okay,
so
update
type
definition,
space
replace,
config,
replace,
replace
config,
replace
config.
What
did
we
do
here?
Okay?
So
what
is
this
patch
all
right?
So
we
we,
this
replacement
so
in
the
base,
dot
py
file
within
the
main
package
within
the
replace
config
function
so
base
colon,
replace
config
colon.
A
Change
input
and
return
signature.
A
A
A
A
Figure
it
out
yeah
instantiate
the
class
when
you
need
it.
Okay,
this
is
probably
gonna
trip
me
up
later.
I'm
gonna
get
really
confused
about
why
we
don't
have
an
instantiated
memory
orchestrator.
If
anybody
is
watching
this
remind
me
when
I
start
getting
confused
for
hours
on
end,
because
this
this
one
usually
gets
me,
so
maybe
we
should
put
to
do
alice.
This
will
need
to
make
sure
we
have.
Is
this
completely
terribly
ergonomic?
A
My
hand
is
like
weird
I'll
need
to
make
sure
we
have
code
to
instantiate
an
instance
of
a
class
yeah.
I
think
this
is
not
right.
There's
something
wrong
here.
A
Yeah,
maybe
I
should
fix
this-
probably
okay,
we'll
need
to
make
sure
we
have
code
instantiating
system,
the
class.
If
I
can't
type,
then
I'm
screwed,
so,
let's
see
we'll
need
to
make
sure
we
have
code
to
entice
and
take
screen
and
instantiate
an
instance
of
a
class.
If
only
a
class
is
given
and
not
an
instance,
it's
not
a
big
problem,
but
we
need
to
make
sure
we
do
it.
So,
let's
go
back
into.
A
But
we
need
to.
We
need
something.
Okay,
you
know
what
here
we
go.
Let's
just
still
leave
that
to
do,
though
alice.
Can
you
just
do
that
for
us,
please,
thanks
ooh,
that
will
be
great
default
factory.
That
is
the
goal.
A
Merge
is
not
defined.
Dfml
diff
base
merge,
where's
base.
A
Okay,
merge,
merge,
make
configure
place,
config
merge,
util
data
merge
import
it.
What
do
we
got?
Cannot
import
blank
from
blank?
Cannot
import
dfml
overlays
installed,
get
correct
if
not
overlays
installed
make
sure
we
copy
paste.
I've
spelt
thing
wrong
way
too
many
times.
Okay,
overlay
equals
dfml
overlays
installed.
Okay.
I
think
this
is
a
case
of
misspelling.
A
A
Dffml
overlays
installed
yeah.
I
think
it
should
be
dfml
overlays
installed
rather
than
installed
overlays,
because
that
sort
of
is
more
clear.
I
think.
A
Unexpected
indent
3,
59,
okay,
you
see
why
I
want
for
help
switching
back
and
forth
between
windows.
Now,
let's
see
I
want
to
just
jump
right
to
that
focus
if
it
pops
up,
but
where
is
it
right
now?
Where
are
you?
Where
are
you
here?
This
looks
familiar
base
now
here?
Yes,
here,
okay
359,
we
have
an
unexpected
indent,
359.
A
B
A
Right:
sweet!
Okay:
where
are
we.
A
Okay,
oh
fantastic,
okay.
This
looks
like
okay.
This
is
a
bunch
of
random
stuff
that
we
were
just
messing
with.
So
let's
just
pull
this
out
of
here.
Okay,
I
think
we
put
most
of
this
in
system
context
anyways,
and
why
are
we
even
doing
this?
Oh
because
we
wanted
to
do
systemcontext.run
directly,
and
so
we
were
going
to
do
await.
A
B
A
C
B
D
A
A
So
this
is
system
contact
system
context.
Okay,
so
now
we
need
to
create
a
plug-in
so
do
for
now
so
cd
we're
gonna
be
able
to
create
plugins
on
the
fly
using
this,
so
that'll
be
fun.
Basically,
you
can
take
python
files
and
turn
them
into
whole
whole
packages,
because
you
have
your
your
tree,
you
have
your
dependency
tree
defined
dynamically
okay,
so.
A
Where
are
we,
what
are
we
doing?
Okay,
so,
let's
go
to
wonderland.
Let's
see
where
should
we
put
wonderland,
okay,
so
entities
entities?
Let's
just
do
system
context,
mkder
system
context.
A
Yeah,
okay,
blank
okay!
So
we'll
call
this
one
system,
contacts.
A
Stuck,
I
think,
let's
see
so
we
need
to
go
to
diff.
Now,
where
are
we
okay?
Not
there
not
there?
Oh
there,
it
is
yeah
ctrl,
b
q
and
then
control
bq,
roll
b,
four
away
control,
b,
q,
four
control
b,
q,
five
control
b
q,
four
switches,
the
panes
and
control
vq
shows
you
which
one
you're
on
okay,
so
arg5.
What
was
that
I
want
to
know
what
that
does.
A
A
A
A
C
E
E
A
A
So
let's
go
ahead
and
jump
back
over.
Let's
actually
do
this.
A
A
A
A
A
Create
a
new
function,
so
let's
just
return
an
async
def
function
first
or
wait:
yeah!
Let's
try
here
we
go
so
this
can
be
our
basics
right,
yield.
A
Right
so,
let's
help
to
check
the
type
checker
out,
because
we
will
be
checking
the
type
and
creating
subsequent
operations,
probably
out
of
system
contacts
themselves
right.
So
basically,
what
we
can
do
is
we
can
do
system
context
deployment.
It
can
return
a
typed
function
from
which
we
can
actually
include
it.
A
Another
system
context
and
we
can
blow
up
the
ast
trees
of
these
things
and
basically
allow
for
hodge
swapping
any
function
for
any
level
of
instrumentation
at
any
locality
wherever
we
want
across
languages,
and
that
also
allows
us,
for
you
know,
data
collection
as
well
right,
because
that's
what
I
mean
we're.
A
Basically,
it's
basically
like
we're
fuzzing,
so
we're
fuzzing
for
more
optimal
configurations,
so,
rather
than
just
integrity,
right,
we're
fuzzing
for
the
overall
architecture
and
different
configurations
thereof,
so
to
find
more
optimal
configurations,
including
you
know,
maybe
things
that
have
better
security
properties.
A
So
let
us
see
here
it
looks
like
we
need
to
analyze
the
operations
without
auto
start,
so
we
can
look
at
input
flow.
So
this
is
our
allow
list,
so
we
don't
have
the
allow
list
let's
yet
so,
let's
put
a
to
do
or
no
okay,
so,
okay,
so
we
don't
have
a
allow
list
for
data
flow
inputs
from
each
origin.
A
Specify
data
flow
data
flow
should
specify.
A
Which
origins
or,
let's
see,
okay
so
allows
for
data
flow
inputs
from
each
origin,
run
top
level
system.
Contacts
for
cli
commands
allow
us
for
data
flow
for
inputs
for
each
origin,
including
including
what
seat
or
origin
values
are
for
acceptable.
A
Inputs
for
now
we
consult
dataflow
dot
flow.
This
is
potentially
correct
already,
but
let's
just
double
check.
B
A
Vs
split
dfml,
df,
df
types:
let's
go
look
at
now
we're
in
so
so
we're
gonna
blow
this
up.
So
now
we're
double
pane
vammed.
We
can
copy
paste
back
and
forth,
so
we
need
to
go
to
class
data
flow.
We
need
to
look
for
flow.
A
Okay
is
flow
itself,
a
structure
I
believe
it
is
or
what
is
flow
flow.
Colon
flow
colon
is
dict
input
flow,
stir,
input
flow,
so
it's
a
mapping.
It's
a
mapping
of
operation
instance
names
to
input
flow
objects
which
are
inputs,
outputs
and
conditionals.
A
Let's
see
representing
yes,
node
inputs
and
conditionals,
representing
the
alternate
definitions
that
they
may
come
from.
Okay
or
alternate
origins
so
and
yeah
get
alternate
definitions.
Okay,
so
we
need
to
look
through
flow
to
understand.
B
E
A
A
A
Okay,
so
deployment
environment,
okay,
so
deployment
environment,
deployment,
environment,
aka
method
for
dataflow,
as
class
aka
output
flows
to
be
overlaid.
A
Or
no
aka.
A
How
do
we
know
what
to
add
here
right
so
funk,
let's
only
take
kwrx
for
now
right
and
then,
let's
basically
just
go
through
here
and
map
kwrx.
You
know
key.
So,
let's
see
so
for
key
comma
value
in
kwrx.items.
A
A
The
default,
whatever
the
hell,
it
is
right.
This
thing
that
says
load
the
default,
then
deployment
environment
equals.
A
A
A
Okay,
I'm
not
even
sure
that
to-do
list
is
a
little
funky.
Okay,
so
woof
all
right!
Here
we
go
time
check,
55!
Okay,
if
we
were
to
load
the
full
deployment
environment.
That
means
we
are
now
running
any
specific
operation,
we're
going
to
analyze
the
analyze.
The.
A
Analyze
the
default
flow
or
analyze,
the
yeah,
okay,
so
anaphor
analog
analyze,
the
analyze
dataflow.flow.
A
C
A
So
if
the
planet
is
iron
and
cell
dot
upside
down
operations-
okay,
let's
actually
take
this
out
here-
produce
a
static
method.
A
So
that
it
takes
a
data,
flow
data,
flow
deployment,
environment
data
flows
and
get
a
funk
okay,
this
will
do
return.
A
E
D
A
B
B
A
Okay,
so
note
this
assumes,
so
we
need
to
remember
this
thing,
so
basically,
this
assumes.
A
A
A
A
Unless
we
execute,
we
apply
overlays,
we
can
execute
and
incorrect
default
and
then
hook
via
overlays
to
take
control.
A
Or
we
could
yeah
or
something
else:
okay,
so
self,
upstream:
okay,
oh
and
then
the
deployment.
E
A
A
If
the
input
definitions
come
from
the
default
deployment
environment,
then
they
will
be
basically
the
input
definitions
of
the
flow
as
a
whole
which
come
from
the
origin
so
to
define
which
origin
our
inputs
are
coming
from.
A
Okay,
okay,
so
when
we
do
this
diploma
environment,
we
should
say
deployment,
environment,
okay,
let's
say
origin.
A
A
E
D
B
C
A
All
right
so
input
definitions,
key
origin,
key
valid
kwrx
items,
overlay
overlay;
okay,
no
overlay!
Oh,
oh!
Yes,
we
do.
We
overlay,
we
say
self.overlay,
okay,
so
maybe
this
shouldn't
be
a
static
method.
Then
yeah.
No,
let's
get
rid
of
that
static
method.
Okay,
yeah
self,
upstream.
A
Okay,
so
self
upstream
operations,
all
right.
So
if
we
choose
a
specific
deployment
environment
here,
we're
basically
going
to
choose
a
specific
operation,
and
when
we
choose
that
specific
operation
we're
going
to,
how
are
we
going
to
do
that,
so
we're
going
to
say
we're?
Basically,
we
should
probably
put
a
conditional
on
it,
so
we
should
probably
apply
an
overlay
that
has
a
conditional.
A
I
don't
really
like
that.
Let's
just
say:
let's
just
not
do
that
for
now,
let's
say
raise
not
implemented
here.
A
Okay,
so
to
do
to
do
alice
figure
out
how
to
okay
not
implemented.
There
are
no
support
for
calling
specific
operations
within
system
context,
slash,
calling
or
slash
different
deployment
environments
yet
via
system
context,
deployment
helpers.
A
Okay,
so
figure
out
how
we
should
maybe
add
conditional
on
target
operation
via
overlay.
A
All
right,
a
little
auto
formatting,
let's
check
out
our
stack
trace.
We
got
that
in
comment.
How
is
this
going?
I
think,
oh,
this
is
the
file
that
we've
been
in
okay.
How
is
it
going
let's
find
out
okay.
So
if
deployment
environment
is
the
load
default
employment
environment,
then
we're
going
to
go
through
self.upstream.flow.
A
We
are
going
to
for
we
want
to
do
iter
tools
list
set
iter
tools
chain.
Where
was
that
that
was
in?
Let's
do
read
differently
of
all
right.
Read
diff,
now,
df
types
class
data
flow
all
right:
okay,
where's,
our
serialization
code,
okay,
auto
flow
from
dick
export,
okay
forward
flow
flow
flow
flow,
okay,
where's
flow
input,
flow,
okay,
flow,
okay,
so
where's
buy
origin,
update,
update
by
origin;
okay,
so
okay,
so
instance,
name
cell
flow
items
by
origin,
set
operation,
dot
stage;
okay,
so
okay,
so
by
origin.
A
A
A
All
right
so
pasted
it
from
163
through
222
and,
let's
see
so
input
definitions,
so
flow
flow.
A
E
A
A
E
A
A
So
here's
the
specific
here's,
the
default.
Okay.
So
then,
in
that
case
we
would
say,
instance,
input
flow
output,
slow
source
conditions,
so
these
are
the
conditions
that
these
are
conditions
which
must
be
satisfied
for
our
origin,
as
well
as
if
output
source
equals
origin
and
then
we'll
change.
This
alternate
this
origin
to
alternet
origin.
E
C
F
A
A
A
Open
source
output
source
alternate
origin.
Okay,
it's
getting
checked
there.
Output
source
becomes
the
alternate
origin
there.
Output
source
is
checked
for
origin
here,
okay,
so
now
we've
got
to
fill
in
these
if
blocks
and
what
do
we
have
well
we're
trying
to
create
this
input?
Definitions,
okay,
so.
A
We
don't
know
about
stage
right
now,
or
maybe
we
should
just
do
yeah,
maybe
if
we
just
went
through
upstream
by
origin,
all
the
stages
right
so
dot
values,
and
then
we
said
that
output,
sir.
So
this
is
our
origin
right.
Then
we
should
have
all
of
our
operations
that
we
care
about
for
that
origin
right.
So
if
deployment
environment
is
low
default
else,.
A
B
A
E
A
A
Restructured
by
stage
and
origin
within
dataflow
dot
by
origin.
So
originally
I
screwed
up
when
we
were
first
just
why
it
took
me
a
while,
and
then
we
ended
up
with
you
know,
going
back
and
forth
on
this
and
changing
the
variables
just
a
second
ago.
So
basically
we're
going
to
go
so
this
goes
across
stages
yeah.
So
this
goes
across
stages.
So
if
deployment
environment
equals
equals
operation
instance
name.
A
Okay
input
definitions
would
be.
B
F
A
All
right,
so
how
can
we
do
this
right
so
raise
our
duplicate
keys?
So
we
can
say
if
lan
input
definitions,
not
equal,
lan
input,
definitions
list.
We
know
that
something
got
screwed
up
when
we
transitioned
from
list
to
dictionary
and
we
de-duplicated
the
keys,
because
there's
going
to
be
tuples
of
is
raise
value
or
raise
value
or
yeah,
raise
duplicate,
duplicate
input,
names,
short
names.
D
A
So
it
was
a
okay
26.
Oh.
A
All
right
so
raised
when
duplicate
a
default
system,
contacts,
context,
execution.
A
Okay,
so
that
leaves
us
with
this,
which
we
should
have
our
input
definitions
as
a
dictionary
now
so
then
we
should
be
able
to
go
through
input
definitions
and
do
a
key
value.
Mapping
of
the
definitions,
yep.
Okay,
so
this
looks
good
to
me.
Let's
try
to
oh,
it
doesn't
look
good
to
the
interpreter.
A
B
A
Okay,
did
we
get
all
that
stuff?
I
didn't
really
go
to
all
that
stuff.