►
From YouTube: Weekly Sync 2021-06-08
Description
Meeting Minutes: https://docs.google.com/document/d/16u9Tev3O0CcUDe2nfikHmrO3Xnd4ASJ45myFgQLpvzM/edit#heading=h.sxl0408qld4x
B
Okay,
so
this
is
a
test
that
I
created
for
this
notebook
compare
model
performance
and
this
is
actually
a
different
kind
of
test.
I
mean
different
from
the
one
that
I
created
before
and
I'm
using
this
tv
patch
to
you
know
mock
this
function.
This
cache
it
download-
and
here
I
call
the
mock
function,
and
here
I
also
use
their
assert
called
with
function
to
check
if
it
was
correctly
mocked-
and
this
doesn't
give
any
warnings
or
anything
it
doesn't
blow
up
here.
B
A
B
B
My
local,
let
me
share
it
again.
Sorry.
B
B
All
right,
so
this
is
the
test
that
I
created,
compare
model
performance,
notebook,
and
here
I
am
using
the
patch
function
for
cachet
download
as
mock
download.
Okay-
and
here
I
call
here
here-
I
call
it
as
well,
and
then
I
use
their
assert
called
with
function
to
cross
check,
if
you
know,
is
throwing
in
the
right
values
the
right
parameters,
yeah.
D
B
It
doesn't
work
here,
but
then,
when
I
ex
yeah,
when
I
print
the
output
of
the
notebook
and
it's
just
not
right
like
it's
using
actually
using
the
function,
that's
present
in
the
notebook
and
when
I
check
my
directories,
I
do
also
have
this
file
in
the
wrong
folder.
A
All
right
so
have
you
tried
doing
instead
of
main
cache
download
doing
the
dfml
util
net.
B
B
B
Yeah,
it's
still
dffmo
slash
wine
quality.
A
B
Oh,
my
god,
but
if
we
do
it
the
other
way
like
before
when.
D
A
You
know
how
about
what,
if
we
were
to
do
something
else
where
we
just
basically
created
temporary
directory
for
each
test,
and
so
so,
when
you
do
that
at
testbook
and
execute
equals
true.
Does
that
mean
before
test
cache
download
is
called
that
the
book
has
already
been
executed.
A
Okay,
so
because
I'm
just
thinking
you
know
it
might
be,
it
might
be
good
to
it
might
be
good
to
just
you
know,
change
directory
to
a
temporary
directory
then
execute
the
notebook.
Then
we
wouldn't
have
to
worry
about
all
this.
A
A
So
if
we
were
to
execute
the
test
book
within
a
temporary
directory,
then
we
wouldn't
have
to
worry
about
mocking
the
calls
to
cache
download
to
delete
various
things
we
we
could
just
we.
You
know
we
would
just
do
like
with
temp
file,
dot,
temporary
directory,
and
then
you
know
ch
stir
to
the
temporary
directory
and
then
you
know,
run
the
test
book
and
then
you
know
it
would.
If
the,
if
the
paths
are
all
you
know,
just
top
level
paths
like
one
quality,
then
it
would
end
up.
A
Just
being
you
know
it
would,
it
would
be.
B
Wouldn't
it
still
be
downloading
it
in
the
same
path
as
the
one
given
in
the
original
notebook.
B
B
B
A
Yep
and
then
it'll,
you
know
the
with
the
width
with
statement.
It'll
just
remove
the
temporary
directory
when
we're
done
and
that
way
we
don't
have
to
deal
with.
You
know
any
of
the
mocks
or
anything
right
right.
That's
probably
going
to
be
our
easiest
thing.
I
can't
I
wonder
why
we
didn't
think
about
that
before,
because
that's
what
we're
doing
with
every
other
test
case,
so
probably
because
of
that
test
book
decorator,
that's
probably
why
it
makes
a
little
more
confusing.
So
is
there
a
way
to
just
call
that,
but
not
as
a
decorator.
B
You
can
use
it
as
a
context
manager.
I
think
okay.
B
About
that,
but
that's
about
it.
A
A
A
And
then
you
could
say
with
testbook
and
then
full
path
to
the
test
book
and
then
or
to
the
notebook
and
then
and
then
you
know
whatever
is
in
the
body
there.
So
basically
you'd
have
three
with
statements.
A
All
right,
sweet,
so
yeah
we'll
do
with
tempter
with
ch
stir
with
test
book,
and
then
at
that
point
you
know
it
should
have
run
right,
and
so,
if
it
it
threw
any
errors,
then
it
would
already
have
exploded
right.
B
A
Okay,
great,
let's
see
so
yeah.
Let's
do
that.
Let's
change
it
to
be
that
and
then
and
then
I
think
you
know
we're
pretty
much
good
on
that
at
that
point.
Right.
B
B
Yeah,
I'm
still
a
bit
confused
about
the
the
automation
of
the
tests
like.
A
Oh
yeah,
so
so
the
automation
of
the
test.
So
basically
so
if
you
write
you
know,
let's
just
go
change
that
test
case
to
do
this
and
then
we
can
sort
of
do
the
automation
here.
It
won't
take
too
long.
A
Yeah
right
now,
because,
basically,
what
you
have
so
take
that
test
book
execute
you
know,
move
it
into
the
body
of
the
test.
Cache
download.
A
I'm
sorry
here,
let's
see,
I
wonder
all
right,
so
so,
okay,
let
me
see
what's
a
better
way
for
explaining
this,
so
so
remember
how
we
talked
about
test,
slash,
test,
doc,
strings,
all
right.
A
Open
there
so,
basically
the
same
same
sort
of
thing,
I
think
so
what
we
can
do
is
we
can
basically
create.
You
know
you
could.
A
So
you
can
have
your
your
your
test,
notebook
class
and
then
skip
over
this
part.
This
is
where
we're
loading
all
sorts
of
objects
from
dfml.
So
basically,
what
we're
going
to
need
to
do.
This
is
the
part
that's
of
interest
to
us.
So
this
is
where
we
create
a
new
test
case
class
and-
and
so
so
basically,
you
can
see
like
that
test
stock
string
and
test
console
test.
That's
where
we're
we're
creating
functions
so
that
mk
test
case
and
mk
console
test
those
just
create.
A
You
know
those
those
are
functions
which
return
a
function
and
that
function
is
the
test
case
for
that
object.
So
what
we
can
do
is
we
can
do
the
same
thing
where
we'll
create
a
function
that
returns
a
function
right
and
that
function,
it
returns
will
run
the
test
case
on
a
specific
notebook
right.
A
So
really
you
know
our
you
know
our
make.
Ipython
notebook
test
function
will
accept
the
path
to
a
ipython
notebook,
and
then
it
will,
you
know
just
return,
a
function
that
does
the
with
tempter,
with
ch,
with
execute
and
it'll
pass
to
execute
the
path
that
it
was
given.
You
know
to
make
the
test
case
out
of,
and
then
we
can.
You
know
set
that
as
a
property
on
your
on
your
test,
notebooks
class
right,
and
so
we
can
basically
do
like
a
for
loop
over.
A
You
know
we
can
use
the
path,
lib
library
to
do
a
for
lip
for
loop.
You
can
use
that
r
glob
function,
so
you
can
do
path
lab.path,
and
then
you
get
the
path
to
the
test
or
you
know
you
get
the
path
to
the
root
of
the
dfml
repo
and
I
think
that's
there's
an
example
of
that
in
here
as
well
or
there's
some
somewhere.
It's
there's
usually
root
dur
in
all
caps
with
an
underscore,
but
so
you
get
the
path
to
the
root
of
the
dfml
directory.
A
You
do
recursive
search
for
anything
with
the
ipython
notebook
extension
and
then
you
go
through
and
you
call
your
make
test
case
function.
You
know
on
on
anything
with
a
with
that's
an
ipython
notebook
right
and
then
you
basically
just
do
you
know
you
assign
it
using.
You
know
you
can
assign
it
using
set
actor
to.
A
In
this
case,
we've
actually
created
a
test
case
class
where
there's
two
functions,
but
we
could
just
have
one
class
right
that
test
notebook
class
and
you
can
just
do
a
for
loop
over
every
five
python
notebook
using
our
glob,
and
then
you
just
do
you
know
you
mk,
you
create
you
use
your
make.
A
Ipython
notebook
test
case
function
to
create
a
new
function,
that's
going
to
be
the
test
case,
and
then
you
can
use
set
at
her
to
say
you
know
set
at
her
note
test,
notebooks
and
so
so
add
this
function
to
test
notebooks
and
then
you
know
make
the
function
called.
A
You
know
this
method
name
right
and
the
method
name
could
be
similarly
to
what
we
did
here
was
we
basically
took
like
the
path
to
the
object
that
we're
testing
here
and
we
sort
of
you
know
we
made
it
underscored
instead
of
slashes
right.
So,
for
example,
if
you're
testing
like
the
cli
version
command,
I
think
it
ends
up
being
like
you
know
that
the
name
in
this
case
it
ends
up
being
the
class
name,
but
in
your
case
would
be
the
method
name.
A
So
if
you
had
like
the
current
notebook
that
you're
testing
that's
under
examples,
so
if
it
was
examples
and
then
x,
notebook
or
x
dot,
I
python
notebook,
then
you
would
have
you
know
the
the
method
name
you
would
create
or
use
for
set.
Atro
would
be
test.
Underscore
examples
underscore
x
right.
A
B
So,
like
we're
running
the
whole,
the
tests
on
the
whole
output
now
right
so.
D
B
About
like
it
would
vary,
and
some
like
some
models,
also
throw
out
some.
You
know
different
kinds
of
outputs
so
like
how
do
we
want
it
to
be
like
generic.
A
B
Yeah,
it
gives
you
the
same
output
as
the
notebook.
A
Okay
and
so
you're
saying
like
if
the
output
changes,
then
then
the
textbook
will
will
fail,
because
it's
not
the
exact
same
output
is
that
what
you're.
D
B
I'm,
like
I'm
not
sure.
A
B
Yeah,
I'm
saying:
should
we
check
that
the
output
is
the
same
like
like
if
you
say
that
we
would
have
a
generic
test
that
would
be
running
for
all
the
notebooks
and
different
notebooks
would
have
different
cells
and.
A
B
Like
like
these,
just
like
I
created
some
over
here.
A
Yeah
that
type
of
stuff
yeah
that
that
yeah,
if
you
did
something
like
that,
you
know
yeah,
I
inject
that
yeah
you
could
put
that
just
in
the
notebook,
even
because
that
way
it
just
stays
with
the
notebook.
The
you
know.
The
thing
is
like:
how
do
you?
A
How
do
you
add
enough
so
that
it's
not
confusing
to
the
end
users
who
need
to
get
the
point
right,
but
is
still
like
minimal
enough
to
test
for
something
right
and
and
if
you
think
that
you
can't
do
it
effectively
within
the
notebook-
and
you
know
to
satisfy
both
those
constraints,
then,
let's
think
about
doing
more
stuff
right.
But
if
you
just
need
to
you
know,
if
you
could
just
maybe
do
an
assertion
on
one
of
those
accuracies
and
it's
probably
enough
to
be
sufficient
right,
then
you
know.
A
Maybe
you
just
say
you
know
at
the
very
end
of
that
block
you
had
assert
accuracy.
4
is
greater
than
0.1
right
and
if
it
fell
below
0.1,
you
would
know
hey
all
right.
Okay,
now,
there's
probably
something
wrong
with
the
rest
of
these
right.
I
don't
know
you
know
you
could
do
it
for
everyone.
You
could
do
it
for
some,
but
yeah
right.
A
The
balance
here
is
you
know
how
do
we
make
sure
that
that
it
doesn't
you
know
the
the
checks,
don't
end
up
confusing
the
user
and
but
right
because
or
else
you
need
to
add
some
sort
of
extra
infrastructure
to
say,
okay,
how
do
we?
How
do
we
do
some
extra
validation?
On
top
of
all
this
all
right
and
and
that's
you
know,
and
that's
that's
up
to
you.
That's
your
judgment.
Call
right
like
what
do
you
think?
A
What's
the
balance
there
and
if
they're
you
know,
if,
if
there
needs
to
be
some
kind
of
different
balance,
then
you
know
that's
where
that's
where
you
know
that
generic
test
case
thing.
You
know
it
might
end
up
becoming
okay.
So
you
do
that
for
loop
and
you
do
all
those
set
actors
right.
But
if
you
found
for
some
reason
that
one
specific
test
case
needed
to
be
different,
you
could
just
write
a
function
right
and
say
you
know,
test
notebook.
A
Blank
equals
my
new
test
function
and
then
the
body
would
be
whatever
you
wanted
right,
so
you
could
easily
override
you
know
what
what
what
the
automatically
generated
test
case
would
have
been
right
and
then
do
more
injections
or
more
whatever,
for
that
specific
notebook
right.
B
I
also
want
to
ask
you
like
the
two
or
three
notebooks
in
the
start
are
like
basic
use
cases
right
and
most
of
the
code
is
repeating
in
all
those
notebooks.
D
B
Would
we
want
to
squash
these
notebooks
into
one
or
do
we
want
to
keep
them
separate.
A
A
B
B
Maybe
we
have
more
of
a
generic
name
rather
than
compare
model
performance
and
moving
between
models,
and
then
we
have
like,
because
these
headings
also
show
up
in
the
documentation
right,
yeah.
D
B
If,
even
if
we
squash
them,
we
would
still
be
able
to
show
it
on
our
documentation
in
sections
yeah.
I
don't
know
if
that
makes
sense.
Yeah.
A
I
think
I
think
I
see
what
you're
saying
yeah
I
mean
and
yeah,
so
so
I
think
keeping
them
separate
right
so
because,
if
you
say
because
you
also
yeah
right
like
at
the
end
of
the
day,
what
does
it
look
like
right
now,
because
I
was
just
looking
at
it
so
so
right
now
we
have
examples
now,
I'm
just
looking
at
the
documentation
under
the
master
branch.
So
we
have
examples
notebooks
and
then
moving
between
models,
import
packages,
and
it
shows
two
levels
deep
here
or
so.
A
It
says
on
the
notebooks
page,
it
says:
moving
between
models,
import
packages,
builder
data
set,
so
you're
saying
you
know
we
may
have
some
repeated
sub
headers,
but
you
know
either
we
could
get
more.
We
might
need
like
a
more
descriptive
title
on
the
document
or
something
or
is
it?
Is
that
what
you're
saying
like?
Maybe
change
the
titles
a
little
bit
so
they're
a
little
more
descriptive
so
that
people
know.
B
Yeah
I
was
saying
if
we
were
to
squash
it,
we
could
have
the
main
title
as
more
generic
and
have
multiple
use
cases
in
the
same
notebook
under
different
subheadings.
Like.
C
Our
data
center,
we
show.
A
That's
c
yeah.
I
think
I
think
that's
a
good
idea,
especially
if
it's
the
same
data
set
being
used,
then
yeah
combining
the
notebooks
probably
makes
sense,
and
I
think
actually
this
is
the
one
downfall
of
that
temporary
directory
is,
is
the
fact
that
you're
going
to
end
up
with
so
the
downfall
to
temporary
directory?
B
A
B
Weren't
we
also
already
doing
that
like
that
was
the
issue
now.
A
A
Yeah
to
test
notebooks
data,
so
so
what
we
can
do
is
we
can
now,
just
instead
of
you
know
how
we're
going
to
create
the
temporary
directory.
We
can
say
you
know,
create
test
notebooks
data
if
it
doesn't
exist
right
as
the
setup
for
each
tests
right.
We're
talking
about
you
know.
First,
do
with
tempter
then
do
with
ch
then
do
with
testbook
right,
and
that's
probably
your
generic
test
case
right.
A
B
I'll,
I
think
I
have
pretty
much
completed
this
notebook.
I
will
push
it
and
later
you
can
review.
B
Enough
time
will
we
should
do
one.
A
Yeah,
so
so
let's
try
to
do
a
one-on-one,
so
this
week
is
probably
not
going
to
work
for
me.
I
got
a
pretty
tight
week
here,
so
it'll
probably
be
next
week.
Is
there
anything
that
you
need
to
that?
You
need
to
talk
about.
You
know
that
you
want
to
talk
about
that's
time
more
time,
sensitive
related
to
the
project.
You
know,
I
think
you
seem.
B
Something
further
next
week,
yeah
no,
I
mean
the
scheduled
notebook
for
the
next
week.
I
have
to
discuss
that.
Okay,
okay,.
A
A
And
loop
over
all.
A
And
then
my
test
practices
will
be
a
function
that
returns
test
cases.
A
Okay,
all.
A
D
A
Sweet
and
then
did
you
see
so,
let's
see
look,
oh
no!
This
is
that
stupid
bug.
I
hate
this
bug.
Oh
my
god.
I
hate
this
bug.
A
A
A
A
D
I
just
wanted
to
give
an
update.
Okay.
A
Yeah,
since
the
ci's
now
passing,
we'll
probably
need
to
make
sure
that
it
passes
obviously
before
we
can
merge
it.
So
we'll
see
how
see
we'll
see
what's
up
with
this,
because
there's
probably
I
mean
it
looks
like
most,
things
are
probably
good,
but
you
know
here
and
there.
A
Okay,
we'll
have
to
figure
this
stuff
out.
I
don't
think
it
should
be
too
complicated.
Hopefully
let
me
knock
on
wood
things.
Last
words:
okay,
all
right,
okay,
great!
So,
let's,
let's
then
hashim,
let's
go
back
to
you
and
see
so
what
what
else
did
we
have
for
you.
B
All
right
so
and
one
of
the
previous
meetings
we
talked
about
how
models
you
can
actually
change
the
hyper
parameters.
A
A
B
A
Yeah,
let's
see
so.
A
A
Okay,
config
properties,
immutable.
I
think
the
next
real
step
on
this
is
is
we
need
to
review
this
document,
though
wait
because
I
think
we
were
going
to
look
at
this
some
more.
A
I
don't
think
anybody
commented
on
this.
Let's
see
so
this
was
the
stuff
that
we
came
up
with
the
immutable
versus
immutable.
A
A
Let's
see
so,
this
was
more
pertinent
to
your
stuff
right,
so
did
we
have
any
to
do's
in
here
to
do?
Maybe
I'm
entering
it
to
do.
Let's
see
this
is
all
the
below
stuff
that
actually
get
copied
into
the
other
file.
I
think
maybe
you
know
what
you
need
to
do.
A
Is
you
need
to
go
implement
this
first,
this
mutable
tag,
so
I
think
this
might
be
necessary
to
do
first
here,
essentially,
you
know,
and
what
we
talked
about
is,
is
that's
really
so
the
field
function
will
need
to
be
modified
at
the
mutable
keyword
argument,
and
I
think
this
stuff
here
just
is
this-
was
I'm
not
sure
if
this
is
finished
yet
here
I
can't
remember,
I
need
to
see
the
to
do
so.
This
stuff
may
not
may
or
not
be
a
part
of
this.
A
I
think
this
might
have
had
to
do
with
this
model
saving
and
loading
it
got
copied
down.
Yeah.
It
looks
like
it
just
stayed,
because
this
is
a
copy
of
the
same
file
that
got
edited
to
be
two
different
files
right,
because
we
started
writing
one
and
then
we
realized
there's
actually
two
things
that
were
involved.
You
know
immutable
versus
immutable
and
then
then
also
saving
and
loading.
What
should
take
precedence,
so
I
split
them
into
two
adrs.
A
So
I
think
what
you
need
to
do
is
go
add
this.
This
mutable
keyword
to
the
field
property
and
then
also
it.
I
think,
if
you
add
the
mutable
keyword
to
the
field
property,
and
then
you
do
this
mutable
callback
thing
and
and
essentially
well,
you
know
what
that
will
be
would
be
basically
like
make
it
so
that
the
config
structure-
let's
see
just
so
this
mutable
callback
thing.
A
A
So,
oh
right,
that's
right!
This
gets
a
little
bit
deeper.
Doesn't
it
because
we're
going
to
have
to
do
config
getters,
like
getters
and
setters,
on
all
of
these
things?
So
basically
like?
Are
we
even
using
the
data
class
stuff?
So,
oh
god,
okay.
A
A
It's
our
data
classes
that
day
of
class.
I
wonder
if
we
end
up
throwing
out
this
whole
data
class
thing
that
probably
causes
problems.
I
bet
a
lot
of
things
assume
that
config
objects
are
data
classes.
A
Okay,
not
terribly
much
okay,
I
did
a
class
okay,
so
we
do
have
a
lot
of
data
class
specific
usage
in
here,
because
the
question
becomes
like
okay,
oh
yeah,
the
thing
was
like:
if
we
need
to
be
able
to
control
the
immutability
of
various
properties,
rather
than
just
the
entire
object
by
itself,
then
we
can
no
longer.
You
know
we
can't
really
leverage
the
data
class
infrastructure
anymore.
A
We
have
to
create
our
own
thing.
That's
very
much
like
a
data
class,
but
it's
not.
A
A
A
A
Oh
geez,
sorry,
let's
see
frozen
instance,
error
frozen
frozen,
frozen
present
frozen,
wait
a
minute
data
class
frames.
Now,
let's
just
do
it
to
the
class
itself
field
sign.
If
we
are
a
frozen
class
frozen
frozen
field
sign
frozen,
I'm
wondering
if
there's
a
way
to
declare
a
field
as
frozen,
because
that
would
be
something.
A
Looks
like
there's
not
a
way
to
get
there
there's
a
field
if
we
could
freeze
a
single
field
now
see
that
won't
really
help
us,
because
we
have
to
have
this
getter
and
setter
type
thing,
so
the
question
becomes
like:
can
we
do
that
and
maintain
data
classness
stuff?
Okay?
So
what
happens?
If
we
try?
Let's
just
give
this
a
try.
Real,
quick
here.
A
C
A
C
A
A
We
need
to
say
dick
or
data
classes,
dot
fields.
So
we
need
to
like
look
at
the
look
at
the
fields
here
and
like
make
them
properties
somehow
and
if
they
like,
can
we
do?
This
is
the
question
right,
so
we
have
this
data
class,
we
created
it
so
now
we
need
to
be
able
to
like
data
class
set
at
her.
A
Okay,
so
git
would
be
well
to
do.
Let's
see,
okay,
where
is
the
data
for
the
data
class
stored?
It's
a
really
good
question.
Is
it
a
dictionary?
Is
it
just
a
property
itself?
I
think
it
might
just
be
a
property
of
the
class
get
field.
A
I
think
I
think
I
mean
the
question
is
like:
can
we
just
override
it
and
then
like?
Does
this?
Stupid
value
exist
like?
Where
does
the
stupid
value
exist
right?
Because
if
the
value
I
mean,
I
guess
it
doesn't
really
matter,
we
can
just
create
the
value
somewhere
else.
It's
like
does
the.
A
If
we
were
to
go
okay,
so
we
create
this
an
instance.
So
if
data
class
is
created
and
it
creates
an
instance
of
class
right
so,
for
example,
remember
user
list-
and
I
don't
know
if
you
guys
remember
the
bug
that
we
had
with
the
user
list
a
while
ago
or
user
dict.
So
if
you
look
at
collections.
A
Collections,
user
dict,
so
here's
an
example
of
this.
Basically,
this
is
like
you
know
what
you
would
subclass
from.
If
you
wanted
a
dictionary
and
then
it
like
a
custom,
dictionary
type
and
then
in
reality
it
has
this
sub
this
property.
That
is
the
real
dictionary,
and
so,
if
you,
you
know,
you
know,
do
a
subtext
into
this.
Like
you
know,
user,
dict
and
then
bracket
a
in
bracket,
it
actually
goes
and
looks
for
you
in
this
data
property.
So
it's
it
goes
and
looks
in
user,
dick,
the
the
object,
dot,
data
dot.
A
You
know
brackets
a
so.
The
question
is:
with
data
classes,
you
know
what
is
it
doing
you
know,
is
it
actually
just
directly
setting
these
properties
or
is?
Is
there
some
kind
of?
Is
there?
Some
kind
of
you
know
thing
thing
like
a
sub
object
like
this,
where
it's
data,
because
if
there's
some
kind
of
sub
object,
then
you
know,
then
we
just
you
know
our
proper.
Our
getter
and
setter
need
to
need
to
pull
from
that
and
set
to
that.
A
B
A
Okay,
cool,
let's
see:
where
is
this
thing
I
don't
know,
I
think
you
know
I
think
it'll
work,
let's
see,
let's
just
let's
just
try
it,
let's
we're
just
gonna.
Do
it
with
a
little
we're
just
gonna,
you
know
we're
just
going
to
say
data
class
dot,
score
mutable.
A
Okay,
and
actually
I
think
what
do
we
have
to
do,
I
guess
we
have
to
go
through
everything.
Don't
we
because
we
want
to
make
a
property
for
everything
and
by
default
everything
is
immutable
or
immutable
right,
so
we
really
need
to
say
mutable
and
then
immutable
equals.
So
these
are
both
just
going
to
be
like
dictionaries.
A
A
A
A
And
then
there's
no
so
set
immutable
is
just
raise
exception.
You
know
to
do
replace
with.
D
A
A
So
by
default
it's
set
immutable
and
you
know
we
pass
it
the
field
name
as
the
key,
so
we
can
do
right.
So
we
use
function
func
tools.partial
here,
because
it
basically
creates
a
new
it
wraps
these
functions
and
it
makes
the
first
argument
to
them.
A
So,
and
I
don't
know,
let's
see
I
don't
know,
what's
gonna
happen,
if
we
do
pro,
if
we
do
property,
what
happens
with
property,
will
it
already
pass,
would
already
pass
self
because
that'll
be
annoying
okay,
it
does
do
yourself
great
thanks
a
lot,
not
okay.
Whatever
we'll
just
do
this,
I
think
this
will
work.
I
mean
I
don't
know.
Do
you
guys
want
to
see
me
finish
this
or
do
you
want
to
just
try
it
try
the
rest
of
this
hashem.
B
Well,
I
could
try
it.
You
don't
have
to
finish
it.
A
A
A
And
then
I'll
just
send
you
this
patch
here
sure
thanks
yeah,
all
right
great,
I
think
that's
pretty
much
it's
just
like,
and
then
you
don't
need
functionals
partial.
A
This
looks
pretty
right
to
me,
but
obviously
you
know
who
knows
so
then
you
need
the
getter
as
well
right,
and
you
know
you
honest,
actually
you
probably
don't
even
need
you
can
just
use
like
data
right
and
that
way
you
could
have
the
getter
be
the
same
thing
yeah.
A
So
then
you
need
a
getter
setter
and
what
was
the
last
one
a
deleter,
so
I
guess
you
you're
not
gonna
have
a
deleter
because
you
can't
delete
the
config
properties
so
to
do
make.
C
A
A
All
right:
well,
I'm
not
sure
why
that's
that,
but
you
get
the
picture
right.
Just
let
me
know
if
it
yeah.
Okay,
let's
just
post
this!
Oh
and
that's
you
don't
care
about
that!
One!
Stupid!
Python,
3.9,
stuff!
A
C
Or
what
is
this?
Swiss
is
immutable.
C
A
A
I've
been
liking,
this
command
line,
github
thing,
it's
pretty
pretty
sweet
all
right,
so
great
all
right.
So
this
is
hopefully
a
start
on
that.
A
Okay
yeah,
hopefully
that
works
out,
but
you
never
know.
A
No
problem,
no
problem,
let's
yeah!
Don't
and
don't
you
know
if
you
start
running
into
stuff
right,
like
don't,
don't
spend
too
much
time
on
it
like
ping
me
and
then
you
know
maybe
work
on
a
different
like
because
you
could
probably
write
the
notebook
without
having
you
know,
maybe
don't
test
it,
but
just
write
sort
of
what
you
think
is
gonna
be
the
code
right,
because
obviously
we
don't
have
we're
gonna
need
to
go
and
and
tweak
scikit
a
little
bit
and
stuff.
A
I
think
for
this,
so
you
can
sort
of
write
the
notebook
code
and
then
come
back
to
this
because
yeah,
don't
don't
don't
if
you
feel
like
you're,
getting
roadblocked
like
sort
of
move
on
to
something
else
right,
because
because
yeah,
this
is
definitely-
and
I
mean
like
I-
I
just
threw
this
out
here
and
didn't
test
this
right.
So
this
could
very
well
take
me
days
too,
because
you
never
know
right.
A
So
so
yeah,
let's
not
let's
like
if
you
feel
like
it's
it's
it's.
If
you
feel
like
it's
there's
something
weird
going
on
like
and
you're
you're,
not
making
progress
after,
like
you
know,
15
20,
minutes
same
same
thing,
weird
stuff,
like
just
ping
me,
getter
and
and
then
I'll
all
I'll
see.
If
I
can
bang
my
head
against
it
and
that
way
you
know
because.
A
Let's
not
listen.
Have
you
bang
your
head
against
this
a
million
times
if
it's
just
gonna
be
because
we
don't
know
if
this
is
gonna
work
right
like
with
this
is
definitely
up
in
the
air
technically,
I
think
it
should
work,
but-
but
obviously
I
haven't
seen
this
before
so
yeah-
oh
cool,
all
right.
Well,
thanks
guys
anything.
B
C
A
A
I
think,
maybe
I
think
I
think
what
happened
is
when
you
removed
the
accuracy
method,
like
that
happened
in
between
the
removal
of
the
accuracy
method
and
the
addition
of
the
score,
and
so
when
we
rebased,
we
didn't
see
a
conflict
because
it
was
in
the
method,
changed
files
essentially
and
so
git
didn't
raise
a
conflict
saying
that
you
know
hey.
We
need
to
go
update
that
file,
so
so
what
ended
up
happening
there?
So
we
just
needed
to
you
know,
take
the
take
that
change
that
would
have.
A
It
would
have
come
up
if
we'd
had
a
rebase
or
it
would
have
come
up
if
the
method
had
stayed
in
the
same
file,
but
since
we
removed
it
and
then
we
removed
the
method
and
then
the
rebase
resulted
in
yeah.
I
don't
know
you
know
what
I'm
saying,
though,
I'm
not
exactly
sure
what
happened,
but
I
think
it's
because
we
removed
the
method
and
then
also
there
was
a
change
to
the
same
method
to
update
it.
But
since
the
method
was
removed,
then
git
doesn't
detect
the
fact
that
it
was
changed.
D
A
Oh,
my
god.
Okay,
oh
no,
I'm
sorry!
Oh
my
gosh!
Well!
Let's
see
that
was
obviously
my
fault
because
I
went
and
tried
to
change
it.
I
don't
think
what
the
hell
happened.
I
swear.
I
tested
it.
A
Still
mad
about
no
spacey
gold-
oh
my
god!
No!
This
wasn't
the
one
that
I
didn't.
Oh
my
gosh,
this
is
I
took.
Did
I
tell
you
guys?
No,
I
think
I
forgot
to
tell
you.
I
deleted
my
dffml
local
copy
this
morning,
which
is
not
my
favorite
thing
to
do:
no
module,
spacey
gold,
where
the
hell
are
you
getting
that
from
or
we're
not
even
using
spacey
gold
anymore?
Are
we
in
here?
A
A
A
Okay,
yeah.
I
think
we
just
need
to
remove
that
one
line
here
I
see
yeah.
I
probably
did
this
and
then
I
was
like
ci.
Okay,
great
sorry
about
that
sweet.
Well,
thanks
guys
have
a
good
one
and
I'll
talk.