►
A
Jump
right
back
into
it
so
now
we're
going
to
validate
the
contributing
documentation,
we're
going
to
do
this
by
looking
at
the
console
test,
so
I
think
you'll
think
you'll,
remember
that
we
played
around.
I
believe
this
was
on
a
stream
stream
of
consciousness,
as
it
were.
Okay,
so
where
did
it
go.
A
A
A
Okay,
let's
replace
these
archive
urls
with
whatever
our
last
commit
was,
so
what
was
it?
A
A
And
then
dot
dot,
vnv
or
let's
see,
let's
pull
it
actually
from
dfm
docs
installation.
And
let's
do
oh
yeah,
that's
right.
Okay,.
A
A
You
may
want
to
create
or
any
permissions
issues,
okay
and
then
always
update,
pip
setup
tools
and
wheels
good
good
practice,
so
keep
keep
keep
things
sane.
So,
let's
remove
the
test
blocks.
Okay,.
A
A
A
A
Okay,
so
this
little
disclaimer
about
the
install
little
virtual
environment
creation,
a
little
bit
of
installation
there,
okay
with
the
okay,
so
note,
and
then
we
have
the
note
okay,
great
all
right.
That
looks
good
to
me.
A
Install
last
known,
good
version
with
v
and
within
b
and
v.
B
A
A
A
A
Get
a
little
refresh,
okay,
so
see
out
rolling
out
for
more
information
on
she's,
our
developer,
helper,
okay,
great
okay,
that
gives
that
link
okay.
So
this
needs
a
backlink
still
so
different
only
supports
three
point:
seven
to
three
point:
nine
on
linux:
if
you
just
pi
and
vi:
okay,
okay!
So
then
this
section
is
not
correctly
formatted
right
now,
but
you
get
the
gist
of
it.
So
then
yeah
it's
doesn't
really
matter!
You
understand
what
to
do
so.
A
A
All
right,
let's
go
so
I'm
gonna
do
this
and
then
we'll
clip
it
so
okay!
So
I
for
those
of
you
who
are
following
the
stream
I'm
going
to
reset
now
as
if
here
we're
resetting
and
then
we'll
clip
the
video
for
this
specifically,
so
that
people
can
can
jump
right
in
here.
A
So
all
right,
so
yeah
we're
looking
at
alice
today.
This
is
the
code
base
and
we're
wanting
to
get
spun
up
to
get
contributing.
So
you
know
first
thing
before
we
get
contributing
we're
gonna
want
to
go
and
and
test
it
out
and
see
what
the
existing
functionality
is
like.
A
So
we'll
go
ahead
and
start
ourselves.
A
shell
here
make
ourselves
a
temporary
environment,
mk
temp
dash
d,
and
oh,
I'm
almost
out
of
disks
disk
space.
So
we'll
see
how
this
goes.
But,
okay,
so
we
want
to
python-mvnv
we're
going
to
create
our
virtual
environment.
A
Do
dot
vmv
bin
activate
activate
the
virtual
environment
right
now
we
do
our
install
we,
we
upgrade
pip
setup
tools
and
wheel,
and
we
update
these
packages
because
they're
commonly
out
of
date,
after
the
creation
of
a
virtual
environment
or
just
in
general,
and
sometimes
our
dependencies
depend
on
these,
which
are
the
packaging
utilities
being
installed
and
up
to
date.
A
So,
okay,
so
now
we
download
the
development
version
of
dfml
identified
by
the
git
sha,
and
so
we
update
this
git
shop
periodically
with
the
sort
of
last
best
known
development
version
and
then
we'll
we'll.
You
know
we'll
we'll
use
the
pi
pi
dev
releases
and
stuff,
eventually
we're
just
not
there
yet
so
we're
installing
from
the
the
zip
repos.
Now
the
zip
repo
offers
you
slight
benefit
in
performance.
I
haven't
tested
versus
the
tar
file
at
all.
A
I
think
it's
pretty
much
the
exact
same,
but
definitely
over
the
git
repo
itself.
It
it
doesn't
do
the
depth
so
it'll
clone
the
whole
history.
You
don't
need
the
whole
history.
You
just
want
the
zip
so.
A
Where
was
she
there?
She
is
we're
going
to
okay,
so
oh
yeah
and
we
can
add,
dash
log,
debugting,
alice
or
dfml
command
to
get
debug
output.
So
now
we
want,
we
want
alice
to
create
a
new
project
for
us.
So
actually
this
will
be.
A
This
should
be
public
and
my
new
python
project-
let's
see:
okay,
so
pdx
johnny,
my
new
python
project,
okay,
so
what's
in
here,
git
clone
all
right,
so
we
created
the
project
through
the
github
command
line
using
the
gh,
the
github
cli
oops,
and
then
we
need
to
clone
the
repo,
so
https
get
clone
https
github.com
px
johnny,
my
new
python
project.
We
have
cloned
an
empty
repository,
all
right,
okay!
Well,
we
know
that.
So
this
is
all
sorts
of
wrong.
A
A
And
we'll
make
the
initial
commit
okay.
So
now
the
repo
has
some
contents
right.
So
we've
got
this
little
test
file
and
it
says
hello
world.
So
here's
our
repo
and
now
along
you
know,
comes
alice
hypothetically
and
she
we're
gonna,
ask
her.
If
she
can.
Please
contribute
the
recommended
community
standards
to
this
new
repo
of
ours,
so
she's
gonna
go
and
she's
gonna,
say:
okay,
it
looks
like
a
repo
url,
I'm
gonna
pull
it
down,
I'm
going
to
analyze
it.
A
Now,
I'm
going
to
look
for
readme,
I'm
going
to
create
a
readme,
so
contribute
readmemd
and
then
she's
going
to
create
issues
to
track
things,
and
so,
let's
go
over
to.
A
The
issues
and
we'll
see
that
she's
created
this
meta
issue
right,
okay
and
she's,
operating
as
our
account
here
right
and
so
also
using
the
gh
command
underneath-
and
we
can
say
all
right-
looks
like
we're
good
to
go
here,
looks
like
alice.
You've
actually
created
a
pull
request
for
us
as
well,
which
fulfills
the
requirements
of
the
issue.
So
we
can
just
go
ahead
and
merge
in
that
poll
request
and
then
our
issue
will
be
closed
and
now,
with
this
meta
issue,
all
the
items
checked
off.
We
can
go
ahead
and
close
the
issue.
A
So
now,
what
we're
going
to
be
doing
is
we're
going
to
be
writing
more
overlays
to
add
more
fields.
You
know
to
the
meta
issue
right,
so
we're
going
to
be
looking
at
security
code
of
conduct,
etc
and
then
we'll
move
on.
Eventually,
you
know,
after
we
figure
out
how
to
get
overlays
working
there
and
contribute
those,
then
we're
going
to
move
on
to
to
starting
now
extending
to
even
more
commands,
rather
than
just
please
contribute
the
recommended
community
standards
all
right,
great,
okay,
so
break
demo
over
so
now.
A
A
So
if
you're
working
on
alice-
and
you
run
into
a
problem,
that
means
you-
you
know
you
gotta
backtrace,
yeah
python
has
this
handy-dandy
built-in
debugger,
which
you
can
use,
and
you
can
just
run
her
through
the
debugger
and
also,
if
you,
if
she's,
not
showing
up
in
your
shell
with
the
path
you
have
a
path
issue.
You
can
run
her
with
that
python-m.
A
A
A
A
A
So
yeah
so
okay,
so
this
next
thing
is
about:
how
do
you
see
all
of
the
the
data
types
that
you
have
to
work
with,
and
so
this
this
might
change
around
a
little
bit.
This
section
is
probably
going
to
change
a
little
bit,
but
right
now
what
we've
got
is
alice
cli
and
then
the
get.
A
It
is,
as
please
contribute
sale
at
dataflow,
so
we
export,
we
give
the
entry
point
style
path
to
the
thing
that
we
want
to
export,
and
then
we
export
it
out
to
where
you
know
wherever
that
is,
and
so
this
now
gives
us
the
open
architecture,
format
document-
and
this
is
a
a
date.
This
would
be
a
data
flow,
manifest
yeah.
This
is
a
data
flow
manifest
which
should
be
taken
as
the
only
document
with.
A
If
we
were
to
look
at
this
as
an
open
architecture
document,
we
would
say:
there's
no
overlay
orchestrator
specified.
Therefore
this
is
the
upstream
and
the
upstream
is
of
type
data
flow,
so,
okay
and
then
from
there
you
can
do.
A
From
there
we
can
say
I'm
just
going
to
pipe
this
through
an
http
server,
so
I
can
grab
the
output
because
it's
it's
over
the
let's
say
so:
df
mile
service,
oh
yeah,
dfml,
dataflow
diagram
and
then
whatever
that
file
name
is
so
let's
check
that
out
and
let's
jump
over
and
say.
A
There's
the
mermaid
diagram:
there's
the
mermaid
diagram,
oops,
don't
png!
We
want
scalable
group
vector
graphics,
all
right.
Let's
check
out
what
this
looks
like:
okay,
wow,
look
at
that
okay,
so
this
will
show
you
in
a
visual
form.
You
know
what
are
all
these
things
and
how
are
they
all
linked
together
right
and
so,
if
you're,
if
you're
a
human
being,
then
you
can
go,
and
you
can
turn
this
into
a
human,
a
human
process
right
that
you
can
do
with
the
data
without
having
to
automate
it.
A
So
you
get
kind
of
some
communication
there.
So
all
right!
So
let's
continue
on
our
con
contribution
journey
here.
So
where
were
we
okay,
okay,
so
making
a
game
plan?
Okay,
so
now
looking
at
so
we're
contributing
something
new
in
in
this
event,
right
and
and
so
we're
looking
at
this
giant
diagram
and
we're
like
well,
you
know:
how
do
we?
What
what
do
we
want
to
do
you
know?
And
and
what
do
we
care
about
adding
to
this?
A
Well,
so
in
in
our
example,
here
we're
going
to
say
that
a
repo
may
have
a
config
called
my
config.
A
Now,
if
the
repo
has
a
config
called
my
config,
we
should
use
that
and
maybe
eventually
we
should
oops,
maybe
eventually
we
might
even
go
so
far
as
to
feed
that
into
the
issue
body
right,
because
you
want
to
know
the
name
or
something
or
you're
going
to
go,
get
the
contact
information
or
something
right,
yeah
or
maybe
yeah.
A
Maybe
you
have
an
overlay
on
this
that
says:
okay,
if
these
recommended
community
standards
aren't
instead
of
like
the
issue
creation
overlay
that
we
have,
you
would
have
one
that
says,
go
email,
somebody,
but
you
need
the
the
name
of
the
email
from
the
my
config
right.
Okay,
so
now,
you're
gonna
write
this
little,
my
config
flow,
so,
and-
and
and
how
are
we
going
to
do
that?
A
Well,
we
need
to
make
a
game
plan,
so
we
know
that
my
config
is
a
json
file
and
that
it
contains
a
single
property
right
now,
which
is
the
value
of
name
which,
which
is
name
the
name
property
right.
A
So
we
want
to
check
if
it
exists
and
if
it
doesn't
exist,
we
want
to
bail
out
right
nothing
more
to
do
here,
in
fact,
nothing
more
to
do
on
the
either
nothing
more
to
do
at
all
and
then
the
subsequent
you
know
if
the
data
is
not
there,
the
the
subsequent
operations
just
don't
run
so
you
know
just
bailout,
then
nothing,
no,
no
more!
Nothing
to
do.
Okay,
so
yeah!
If
it
is
there,
we
want
to
read
in
the
context
parse
it
as
json
and
then
return
the
parse
contents.
A
A
So
then
you
know
we
should
do
some
validation
there
right
now,
we'll
just
do
it
to
do
and
then
finally,
we
should
return
the
name
property
of
the
parse
contents
and
so
there's
a
little
bit
of
documentation
around.
You
know
how
the
dataflow
orchestration
works
itself,
but
of
course
you
can
call
the
functions
on
on
their
own
if
you
wish.
So
you
can
just
write,
you
know,
other
other
other
other
files
right,
but
we're
going
to
keep
things
we're
going
to
try
to
keep
things
modular
here.
A
So
my
config
all
right.
So
writing
operations,
so
yeah,
okay,
so
okay,
yeah!
So
let's
write
just
this
stuff
and
we'll
well,
I'm
gonna
go
quickly
here
to
just
validate
the
docs,
but
we'll
say
cat,
okay,
so
and
we're
supposed
to
be
in
yeah
entities
alice
right
now
so
cat.
My
config.py.
A
A
A
A
A
Okay,
so
it
actually
captured
that
it
output
it
output,
this
line
for
some
reason,
and
I'm
not
sure
why.
So
that
must
be
a
something
that
I
don't
quite
understand
about.
I
guess
it's
just
because
we
just
did
it
down
that
line
down
by
itself,
okay,
whatever
all
right
so
great
there
we
go.
So
let
me
just
fix
that.
A
There
goes
pat
flipped
out
path.
Okay,
there
we
go
okay
and
then
what's
the
next
step
for
contributing
to
alice.
Okay,
so
then
writing
the
overlay.
Okay,
so
now
yeah.
So
this
is
its
own
distinct
thing
right.
So
these
you
know
they
their
functions,
which
know
how
to
do
this
stuff,
but
they
don't
really
do
much
for
us,
so
we
need
to
connect
them
up
with
the
with
the
rest
of
the
world
as
it
were
being
then
the
rest
of
the
world
being
this
recommended
community
standards.
A
A
A
Okay,
my
config
directory
otherwise
looks
like
it
works.
Okay
and
now
what
are
we
supposed
to
do?
Okay,
we're
supposed
to
register
our
overlays?
Okay,
that's
right.
Okay,
so,
and-
and-
and
I
was
going
for
you
know-
I
think
we
should
have
this
hierarchical
overlay-
registration-
not
really
hierarchical,
but
like
object-based
or
not
object-based,
but
basically
just
like
unique
entry
point
based
or
section
based
here.
This
should
be
the
target
and
then
we
should
sort
of
recursively
apply
all
of
them
that
are
relevant
that
get
loaded.
A
A
A
A
So
that's
probably,
and
we'll
put
them
at
the
end
here:
okay,
so
there's
one
more
piece
of
this
which
we
haven't
implemented
yet,
which
is
what,
if
the
load
call
returns
a
a
module
and
so
we'll
go
over
and
we'll
flip
over
and
we'll
we'll
implement
that
after
but
yeah.
So
basically,
at
this
point
we
reinstall
the
package.
A
And
we
should
now
have
okay,
so
did
I.
I
did
duplicate
entry
point
found
indeed.
A
Okay,
so
we
should
have
registered
our
overlay
by
now.
So
now
what
we
can
do
is
we
can
push
this
file
this
my
config.json
to
the
repo,
and
we
should
see-
let's
see,
we
should
see
that
that
my
config
reader
gets
run
so
and
we
should
see
a
config
name.
So,
let's
see
get.
A
A
A
A
Okay,
so
it's
mad
because
we're
giving
it
a
whole
module
at
line
five:
seven,
six:
five,
seven,
six!
Okay!
So
because
it
says
module,
blank
has
no
attribute
module
right
so,
but
but
we
were
not
treating
it
like
that.
Okay,
so
op,
amp,
okay,
so
for
class.
So
let's
maybe
do
if
class
is
if
inspect
dot
is
module.
A
A
A
Let's
split
this
out,
hopefully
this
will
be
easier
for
us
to
to
deal
with
all
right,
so.
A
A
A
A
Or
no,
let's
actually
just
say:
if
inspect
dot
is
module.
A
A
A
A
A
A
B
A
A
So,
where
is
okay
looks
like
validate
my
config
okay.
So
now
we
see,
I
love
this
okay,
so
my
config
project
name,
like
my
config,
result.
Okay,
we
have
an
issue
here,
so
this
is
validating
my
config
and
my
config
project
name
takes
config
both
from
the
same
thing
so.
A
Okay,
so
yeah,
so
here's
the
overlay
we
added
and
it's
going
to
basically
just
grab
that
repo
object,
why
it
has
multiple
arrows
going
to
it.
Probably
a
config.
A
A
It
should
be
getting
run.
So,
let's
take
a
look
at
the
output.