►
A
A
B
B
A
B
A
A
C
B
D
B
C
D
B
A
B
B
B
C
A
B
A
A
A
B
A
D
A
B
A
B
I
know
why
I
didn't
do
this
because
there's
line
breaks
that
are
off
whatever
goddamn,
okay,
there's
tutorials,
which
reference
certain
lines
and
we
have
a
job
that
goes
through
and
tells
us
when
those
lines
need
to
be
updated,
and
this
will
trigger
that
job
because
we're
modifying
this
file
where
we're
including
parts
of
this
file
and
that's
yeah,
that's
why
the
imports
are
structured.
The
way
they
are.
B
B
B
B
So
we
check
so
we
we
by
doing
alice
remote
within
check
if
give
repositories
valid
or
get
within
this
operation.
Clunky
repo
will
not
run
without
an
input
of
definition,
valid
repository
url.
So
true,
this
will
prov.
This
is
to
prevent
attempting
to
clone
repos
where
clone
results,
an
infinite.
Hang
we
prevent
this
by
checking
the
repo
if
we
prevent
this
by
checking
if
the
repo
is
valid
to
begin
with
by
doing
or
before
clone.
A
B
B
B
B
B
B
B
A
B
B
A
A
A
A
B
D
B
B
So
we're
going
to
be
able
to
use
our
input
definitions
to
take
either
p
urls
or
software
heritage
ids
determine
those
also
automatically
and
determine
that
they're
different
from
a
gate,
repo
url
and
then
run
the
appropriate.
You
know
translation
layers
there.
So
let's
go
look
at:
let's
see
operations,
inner
source,
dfm
operations
intersource,
and
how
did
we.
A
D
B
B
B
B
So
maybe
each
cli
command
is
like
a
deployment
environment
right
and
then,
as
we
get
down
we're
diagramming
each
deployment
environment
right.
So
if
we
do
a
diagram,
we
could
diagram
for
the
top
level
right
and
then
we
could.
Let
me
write
that
down
because
that's
going
to
be
a
that's
going
to
be
helpful.
B
B
B
B
Command.
Okay,
so
this
this
whole
cli
util
cli,
is,
is
the
wrapper.
So
when
we
go
here,
we
basically
look
at
the
data
class
fields,
see
we
look
at
the
data
class
fields
and
we
create
these
argue.
There's
this
intermediate
structure,
because
there
was
some
there's
a
lot
of
hold
over.
Remember:
we've
been
redoing
the
config
vote
code
for
the
lifetime
of
the
project
right
so
hopefully
soon
we'll
finally
unify
well.
We
figured
out
the
type
stuff.
B
Now
we
need
to
go
implement
right,
but
so
we've
got
the
data
class
fields
we
iterate
over
them.
We
create
these
intermediate
structures,
these
args,
and
then
we
add
the
args
right,
so
we'll
get
rid
of
that
and
we'll
just
do
it
do
directly
from
fields.
If
anybody
has
time
that
would
be,
you
know
a
really
good
thing
to
do
so
and
and
then
yeah
we
add
arguments.
B
So
basically
what
this
means
is
that
each
of
the
so
these
fields
within
the
data
class
right
they
become
sub,
commands
right
unless
they
have
a
or
actually
let's
see,
that's,
not
actually
what
that
part
means
the
fields
become
the
arguments
and
the
yeah.
So
we
inspect
the
members
of
the
class,
and
so
any
member
of
the
class
wears
so
so
these.
So
basically
this
use
command
when
set
so
yeah
yeah.
B
Is
the
deployment
environment
right
for
that?
Given
data
flow,
we
talked
about
having
these
sort
of
top-level
deployment
environments
right,
these
top
level
switches
for
our
almost
like
our
data
flows,
class
we're
doing
the
different
methods
within
the
one
data
flow
that
we're
calling,
I'm
probably
triggering
them
using
its.
You
know,
sub
flows
based
off
of
conditional
in
the
top
level
right
where
we're
gonna
pick
that
out
and
see
what
you
know.
B
Okay,
it's
it's
run,
okay
and
then
we're
gonna,
add
the
conditional
and
then
we'll
do
the
subflow
and
the
subflow
would
be
this
run
right.
So
diagram
makes
sense
as
something
that
we
would
put
in
at
every
level,
then
because
we
would
be
able
to
diagram
any
any
cli
command,
and
this
and
the
different
subflows
provided
they're
all
based
on
data
flows,
which
they
should
be
right.
Eventually,
we
will
get
there.
A
B
B
B
So
what
the
hell
we'll
update
it
right
now
set
nu,
so
it
used
to
go
to
85
and
it
still
goes
to
85.
wait
a
minute.
Okay,
no,
that's
a
different
file.
We
edited
okay!
I
don't
even
think
we're
looking
at
use.
Okay.
Well,
then
it
doesn't
matter,
then
it
doesn't
matter,
okay,
great
at
least
for
our
messing
around
with
the
other
file
or.
B
B
A
A
B
B
B
A
B
B
B
So
should
should
I
reuse
this
alice
says
gtfo,
you
stopped
editing
the
file
in
the
middle
okay,
rightfully
so,
okay,
so
should
I
reuse?
Should
I
install
so
this
would
be
use
is,
should
I
install
so
should
I
cli
install
so
we're
just
tweaking
this
slightly
for
a
different
model
here
right,
because
we're
going
to
add
our
overlays
and
what
should
I
thinks
is
install
we're
going
to
say
is
used
because
we're
going
to
expand
beyond
python
packages
right.
B
Should
I
just
going
to
focus
on
python
packages
we're
going
to
leave
that
alone?
For
now,
that's
pretty
much!
It's
pretty
much!
You
know
it's
a
it's
a
little
example
right.
It
doesn't
need
to
be
more
than
an
example
for
dfml
alice
is
going
to
be
a
little
bit
more
full-fledged
right.
So
should
I
run.
B
All
right
so,
should
I
use
something.
Should
I
reduce
something?
Should
I
contribute
to
something
right?
Basically,
you
know
what
would
would
we
then
this
is.
This
is
going
to
be
how
we
can
figure
out
basically
at
any
given
time
you
know
is,
for
example,
we
talked
about
the
tutorials
a
long
time
ago,
and
what,
if
I
have
a
different
version
installed,
and
how
do
we
put
the
version
information
into
the
tutorial
doc
so
that
you
could
have
this
command,
which
goes
and
double
checks
your
environment
right?
B
Because
we
all
know
that
setting
up
your
environment
is
definitely
the
most
difficult
part
of
actually
doing
anything
right,
and
so,
if
we
could
just
have
alice,
go
and
say
hey,
you
know,
should
I
use
this
tutorial
right?
Well,
okay,
she
may
come
back
and
say:
well,
you
know
your
environment.
Is
you
know
it's
on
fire?
You
know
that
dog
on
fire
mean
that's
your
computer
and
you
need
to
clean
up
your
computer
and
you
have
10
different
versions
of
python
installed
and
I'm
you
know,
and
by
default
you
pick
the
wrong
one.
B
So
you
need
to
go
fix
that
before
you
try
to
run
this
tutorial
because
you're
going
to
hose
your
computer
even
more
right,
so
that
could
be.
You
know,
maybe
some
of
the
context
that
we
put
around.
Should
I
use
right,
you
know,
but
you
can
also
apply
your
organizational
overlays
which
we're
going
to
get
to
in
a
moment.
B
Right
so
should
I
reuse
and
should
I
contribute
or,
and
so
we're
actually
going
to
make
a
new
contribute
command,
so
we're
going
gonna
say:
should
I
cli
contribute
and
we'll
just
capitalize
that
c?
Okay?
Should
I
re
should
I
use?
Should
I
reuse?
Should
I
contribute
and
then
diagram
all
right
so
should
I
should
I
diagram
right?
That's
just
going
to
produce
a
diagram
of
the
should
I
stuff
so
alice.
B
All
right
well,
what's
in
there
project,
cli
project
command,
project
command,
create
okay,
so
there
we
go.
So
you
know
we.
Basically
what
are
we
doing,
we're
just
sort
of
grabbing
other
pieces
of
different.
You
know.
We've
got
a
lot
of
different
little
projects
right
and
we've
been
structuring
like
this,
so
that
we
can
pull
them
together
and
overlay
where
we
need
right,
and
so
now
it's
time.
Okay,
so
should
I
should
I
do
we
even
need
this
inner
source
stuff
in
here?
So
what
are
we
going
to
do
with
that?.
D
B
What
do
we
got?
Okay,
so
a
bunch
of
git
repo
operations,
okay,
so
very
similar,
so
it
produces
a
bunch
of
metrics.
So
maybe
we'll
call
that
so
alice
should
I
use.
Should
I
reuse?
Should
I
contribute?
Maybe
we're
going
to
throw
this
under?
Should
I
contribute
we'll
just
say:
should
I
contribute
right
now
is
the
running
of
this
inner
source
cli?
D
B
A
B
Alice,
what
can
you
do
alice
can
do?
Should
I
alice?
Can
I
spell?
Should
I
write
probably
not
alice?
What
should
I
mean?
Okay,
so
alice
says
that
we
can
do
this.
Should
I
contribute
install
project?
Reuse
use,
okay,
so
why
does
she
say
that?
Well
she
says
that
because
we
subclass
from,
should
I
cli
itself,
and
we
actually
don't
want
to
do
that
right
now.
So
we
want
is
alice.
Should
I
use
reuse,
contribute
great,
that's
what
we
want
to
see
so
should
I
use
what
does
that
do?
B
As
part
of
our
python
package
evaluation
right,
so
all
we
have
to
do
is
just
say
so,
because
the
install
is
an
overlay,
it
just
becomes
one
thing
that
will
happen
if
it
sees
an
input
right,
so
we
don't
even
have
necessarily
have
to
call
it
an
order.
It's
just
like
a
thing.
That's
going
to
happen
right.
A
B
B
B
B
She
what
she
knows
about
the
health
of
it
and
it's
community
right.
This
will
help
us
make
an
informed
decision
as
to
if
we
should
contribute
should
we,
you
know,
maybe
they're
not
active
right,
maybe
there's
no
maintainers.
Maybe
I
shouldn't
even
bother
going
and
writing
a
pull
request
right.
So
what's
the
first
thing
you
usually
do
you
say
I
have
a
problem?
Is
there
an
open
issue
right?
If
there's
an
open
issue,
then
is
there
an
open
pull
request
right?
Is
it?
Is
there
a
reason
that
pull
request
hasn't
been
merged?
Okay?
B
So
if
they're,
if
it
looks
good
they're
just
waiting
on
somebody,
you
can
always
pull
down
the
patch
right.
You
might
need
that
patch.
I
think
that
we
we
went
over
that
when
we
were
doing
there's
a
blog
post
about
setting
up
the
kernel,
ci
environment,
we
had
to
pull
down
patches
right.
So
you
know
you
you
don't
know,
and
so
what
alice
is
gonna
do
is
she's
gonna
help
us
understand.
You
know
how
ready
is
this
repo
for
my
contribution
right?
Are
they
facing
a
huge
backlog
right?
Okay?
B
Well,
if
they're
facing
a
huge
backlog
of
pr's,
I
might
go
prioritize
my
contribution
to
another
repo
while
they
sort
their
stuff
out
right.
So
this
will
help
us
right
as
we
and
and
the
build
tree
organization,
obviously
same
same
thing.
That's
why
we're
looking
to
you
know.
Eventually,
you
know,
try
to
figure
out
what
what
the
right
arrangement
there
is
see.
B
If
maybe
we
can
get
dfml
into
the
governance
structure
right
of
our
maintainers
of
our
of
our
maintainers
and
mentors
who
are
previously
on
the
project
right
as
they're
building
this
new
org,
and
this
will
help
their
new
contributors
figure
out.
Where
are
their
skills
right?
Where
are
their
skills
relevant
right?
So
if
I
run
this
because
I'm
going
to
have
my
overlays
right,
so
I
can
point
alice
at
a
repo
and
she'll
say
hey.
You
know.
This
looks
like
a
really
good
repo
for
you
to
contribute
to
all
the
open
issues.
B
B
A
B
B
B
B
Great
there
we
go
there's
our
issue
all
right,
so
let's
go
ahead
and
right
and
ideally
ideally
alice
would
be
hooked
into
our
development
environment
right
and
she
would
just
log
that
issue
for
us
right.
Every
time.
There's
a
stack
trace
boom
blog,
an
issue,
deduplicate
log
issues
right
that
way,
we're
all
communicating
right
and-
and
she
can
go
look
at
the
issues
to
see
if
somebody
else,
if
she
sees
the
stack
trace,
she
can
look
at
the
issues
right
and
she
could
say
somebody
else
has
already
figured
out
this
issue
right.
B
Don't
you
don't
even
need
to
bother
spending
the
rest
of
the
day
doing
this
thing
that
somebody
else
already
figured
out
right?
It's
hopefully,
gonna
save
a
lot
of
time.
The
amount
of
random
stack
traces
that
we
end
up
with
during
development
that
we
like
just
forgot
a
flag
here
or
there
right,
she's,
just
gonna.
B
She
can
just
fix
that
for
us
right
well,
she
will
be
able
to
if
we
if
we
were,
but
only
if
we
write
everything
down
right
and
and
and
we
don't
do
that-
so
you
know
sometimes
we
do
like.
We
just
did
right,
okay,
so
bad
example,
but
you
know
sometimes
we
don't
have
time
and
she'll
do
it.
For
us
is,
is
part
of
the
goal
so,
and
what
did
we
name
that
we
named
it?
A
A
B
B
B
B
B
B
Python
alice
right,
so
this
little
main
is
so
that
we
can
call
alice
from
there.
Sometimes
why?
Why
do
we
do
that?
Well,
sometimes
people's
path
does
not
contain
the
console
scripts
directory,
so
in
which
case,
instead
of
making
people
search
for
your
console
script,
just
export
your
module
as
a
library
or
export.
B
Your
export
just
run
create
this
main
file,
and
this
main
file
is
just
kind
of
like
it's
just
like
that,
if
name
equals
main,
but
for
your
module
so
that
you
can
get
run
with
dash
m
and
then
python
will
just
find
the
location
of
your
installed
module
and
run
it
right.
So
what
we
do
is
instead
to
avoid
duplic,
so
to
avoid
creating
too
many
different
code
paths
on
that
cli
entry,
we're
just
going
to
load
the
entry
point
and
that
that
helps
us
reduce
our
our
amount
of
variation
there.
B
B
B
Maybe
the
shots
do
match.
So
if
we
walk
reflogs,
we
can
see
the
different
states
that
git
has
been
on
locally.
It's
kind
of,
like
you
know,
there's
this
sort
of
just
cache
of
stuff
sitting
around
all
right,
so
we
gotta
get
all
right.
I
gotta
get
going
and
then
I'll
be
back
pretty
soon
here
and
we'll
start
again,
thanks
bye.