►
From YouTube: How does dffml/skel/ work 2021-02-04
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
A
So
all
right,
so
this
is
the
scale
format
and
the
the
skeleton
is
this
concept
that
you'll
see
in
like
okay.
Let
me
close
all
these
skeleton.
Is
this
concept
that
you'll
see
in
in
etc
so
etc
scale?
And
so
the
idea
here
is
that
when
you
create
a
new
user,
then
you
end
up.
So
if
you
do
user,
add
m,
which
means
create
a
home
directory
test
user
pseudo
s?
U
r
s!
U!
A
And
we
see
that
all
those
files
exist
for
test
user,
so
the
the
idea
here
is
you
use
this
as
as
you
you
fill
out
like
I
don't
know
now,
I'm
thinking
it's
probably
the
word.
The
reason
they
use
skeleton
is
because
the
body
of
the
user
is
based
on
the
skeleton.
So
that's
that's.
The
idea
here
is
that
you
know
all
these
things
basically
like
how
we
create
new
grid
repository
and
we
get
all
those
files
read
me,
get
ignored,
etc,
yeah
exactly
yeah,
you'd,
usually
you'd,
usually
go
create.
A
Those
or
sometimes
github
can
create
them
for
you
right,
yeah,
and
so
that's
just
like
sort
of
the
basis,
your
backbone
right,
yeah.
Your
skeleton
of
of
your
of
you
know
whatever
you're
doing,
and
in
this
case
it's
a
user
in
in
our
case
with
dffml,
it's
the
kind
of
plugin
that
you're
creating.
So
we
have
several
different
kinds
of
plugins.
A
Let
me
just
remove
that
all
right,
so
we
have
several
different
kinds
of
plugins
and
there's
some
that
some
stuff
that's
shared
between
them.
So,
with
the
with
the
models
you
know,
we've
got,
we've
got
yeah,
we've
got
our
tests
and
I
think
our
test
integration
here
does
the
console
test
stuff
and
yeah.
A
So
so
every
every
you'll
notice
that
every
kind
of
plug-in,
so
the
config
loader
the
model
operations
service,
source
right
and-
and
I
think
we
can
see
in
the
tests
here-
ci
run
you'll
notice
that
where's,
where
I'm
plugging.
A
Then
plug
in
okay,
so
you'll
notice
that
this
is
so.
This
is
the
main
ci
job,
for
you
know,
testing
a
plug-in
right,
and
we
have
this
if
statement
to
say:
okay,
if
we're
testing
the
main
package,
if
we're
not
testing
the
main
package,
we
just
run
the
examples.
After
we
run
the
packages
test,
we
are
testing
the
main
package.
Then
we
want
to
go
and
we
want
to
try
to
run
the
create
command
using
each
of
these
plugins
right.
A
A
Okay,
grabs
us
grabs
those
parameters
and
then
it
looks
in
here
and
it
creates
so
it
copies
over
all
these
files,
and
I
thought
it
had
some
copy
and
logging,
but
basically
it'll
copy
over
all
these
files
in
model
and
then
it'll
copy
over
all
these
files
in
common
and
so
there's
a
specific
way
that
this
is
set
up
also
so
that
we
can
go
and
test
these
packages.
A
So
if
I
go
into
this
package
that
I
just
created,
I
can
run
you
know:
python
dash,
m
unit
tests
dash
oops,
v
and
it'll
run
all
the
all
the
tests.
Obviously
okay,
I
haven't
installed
the
model
here
so
that
one's
going
to
fail,
which
is
the
console
test
ones,
but
so
if
now
so
so
say,
that's
that's
when
the
models
you
know
I've
run
instantiation
and
I've
created
the
I've
created
it
itself
right.
A
So,
if
I
wanted
to
go
in-
and
I
wanted
to
work
on
the
tests
for
one
of
these
like,
for
example,
the
test,
let's
go
test
operations
or
wait.
What
happens
if
we
do
test
no
yeah?
I
guess
test
model
may
not
work
right
now
because
and
we'll
see
why.
But
so,
if
I
wanted
to
go-
and
I
wanted
to
run
the
test
on
one
of
these-
I
can
go
in
there
and
I
can.
A
A
Okay.
So
now
you'll
notice
that
we
have
all
these
symbolic
links
into
the
common
folder,
and
so
the
common
folder
is
meant
so
that
we
we
don't
have
to,
because
what
happened
is
that
initially,
when
we
did
this,
we
had
to
keep
all
these
files
in
sync.
So,
like
the
version
file,
you
know
the
pi
project
license
and
the
setup
file
and
and
things
kept
things
kept
getting
out
of
sync,
and
then
there
would
be
issues
and
we'd
be
like.
A
Oh,
we
squash
one
bug
here
and
then
we
have
another
bug
there,
and
so
now
what
we
have
is
is
we
have
this
system
where
we
basically
just
simlink
into
common
and
now
when
we
run
the
tests
it
can.
You
know
it
finds
the
correct
thing.
So,
if
you're
ever
working
on
these,
you
should
be
able
to
go
run
the
tests
in
them,
and
that
has
to
do
so
all
all
of
this
replace
import
package,
name
and
stuff.
This
ties
into
these
setup
files.
A
So
this
one-
and
this
is
this-
is
sort
of
you
know.
Each
package
has
its
own
setup
file
and
this
is
part
of
why
we
have
setup
instead
of
common,
and
so
that
was
to
make
it
so
that
you
know
we
have
this
minimal
setup
file
where
the
users
are
only
you
know,
overwriting
what
they
want
now.
This
turns
out
to
probably
not
be
the
best
idea.
You
know
we're
hiding
we're
hiding
some
stuff
from
the
users,
and
so
they
may,
this
may
make
them
confused
and
so
so
yeah.
A
So
I
think
you
know
better.
Better
pro
path
for
us
is
to
to
moving
forward.
Probably
move
to
these
setup
config
files
and
sort
of
ditch
the
setup
py
file
altogether
and
just
have
some
more
replacement
happening
in
there,
and
I
think
you
know
part
of
that
was
that
everything
has
its
own
entry
points
right,
so
we'd
we
need
to.
We
need
to
basically
so
the
entry
points
we
defined.
A
You
know
as
a
blank
thing
here
and
then
we
filled
them
in
in
the
in
the
main
one,
and
so
we're
just
gonna
need
to
add.
So
within
this
this
scale
infrastructure
when
it
copies
it
goes,
and
it
replaces
all
these
things
that
say
replace
you
know
these
sort
of
in-caps
variables
anywhere.
It
sees
them
within
the
whole
directory
tree
of
the
thing
that
it's
copying,
and
so
we
to
in
order
to
sort
of
for
for
the
sake
of
the
develop
like
for
this.
This
is
where
it
gets.
A
Sort
of
tricky
is
because,
when
we're,
you
know,
in
order
for
us
to
be
able
to
run
these
tests
here,
we
have
to.
We
have
to
make
this.
We
have
to
make
it
so
that
you
know
our
entry
points.
Well,
I
guess
we
didn't
install
the
package.
We're
going
to
have
to
take
another
look
at
this
right
because
I
don't
think
the
model
tests
work
because
it
would
need
to
be
installed
yeah,
so
it
would
need
to
be
installed
to
run
that
that
console
test
plugin.
A
So
we're
gonna
need
to
take
a
look
at
this
again
and
evaluate
what's
going
on
here,
but
the
main
reason
why
it
was
done
this
way
was
because
then
you
can
put
the
entry
points
in
the
separate
file,
keep
the
common
file
the
same
using
the
sim
link,
and
that
way
you
can
go
into
these
directories
and
still
run
the
tests,
which
was
you
know,
something
that
it
becomes
very
frustrating
to
work
on
these
skeleton
projects.
A
If
you
can't
run
the
tests
within
there,
if
you
have
to
rerun
the
create
command
every
time
it
it
becomes
frustrating.
So
that
was
part
of
the
design.
You
know
what
was
going
on
here.
Do
you
have
any
sort
of
questions
about
that?
Oh
no!
No!
I
think
it
was
awesome,
great
great,
okay,
good,
I'm
glad
we
got
to
talk
about
that.
I
can
post
that
somewhere.