►
From YouTube: Weekly Sync: 2019-10-15
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
Cool
all
right,
so
the
first
thing
today
I
wanted
to
talk
about
is:
should
we
move
the
features
to
config
I?
Don't
think
we
really
finished
that
discussion
on
the
Gator
Channel.
B
A
Basically,
in
the
way
that
the
model
takes-
oh,
no,
that's
not
really
where
I
want
to
go
so,
models
take
config
as
their
argument
right
and
then
and
then
they
take
features
as
an
argument
to
the
context
and
so
right.
So
we
take
features
here
as
the
argument
to
the
context.
A
B
All
of
this,
where
is
it
well.
A
Okay,
so
the
regression
line
stuff
like
we're
reaching
into
the
parent
object
that
actually
does
the
loading
and
then
you
know
deciding
based
on
the
features
what
we
want,
and
so,
if
we're
reaching
into
the
parent
to
grab
the
features,
then
maybe
the
parent
should
just
know
about
the
features
and
like
we
could
just
use
a
separate
file
for
each
thing,
because
I
was
thinking
about
like
tensorflow
and
the
way
that
tensorflow
works
with
the
guy
who's.
Doing
that
new
poll
request
or.
B
Oh
I
guess
he's
not.
He
hasn't
made
a
pull
request
for
that
yet,
but.
A
He
was
looking
at
the
tensorflow
stuff
and
it's
it's
the
way
that
it
works
is.
It
also
creates
the
model
directory
based
on
the
features,
and
then
he
realized
that,
like
the
the
hidden
stuff
is
also
a
part
of
it
and
then
then
I
started
thinking
all
right.
A
B
A
Yeah,
so
basically
the
deal
is
the.
The
problem
is
right
now
that
these,
so
these
args
and
config
method
are
basically
they're
helpers
to
to
bridge
the
gap
between
like
argument
parsing
on
the
command
line
and
these
python
classes
that
are,
you
know,
subclasses
have
named
Tuple.
A
A
B
So
when
we
did
well
I'm
just
giving
master
all
right
so
when
we
did
scikit
psychic
base,
okay,
where
is
that
all
right?
Let
me
make
this
a
little
bigger!
B
A
When
we
did
all
this
wacky
magic
in
here,
we
did
this
from
collections.
Important
named
Tuple
and
I
believe
the.
B
A
Yeah
config,
okay,
so
we
did
this
name
Tuple
right
and
the
reason
why
we
did
it
this
way
instead
of
the
typing
name
Tuple,
which
is
where
we
use
everywhere
else,
was
because
we
didn't
put
a
comment:
I
should
have
put
a
comment
was
because
you
can't
specify
type
hints
and
default
values
to
the
typing
to
typing
version
of
named
Tuple.
A
A
B
Cool
okay,
so
let's
see,
let's
just
make
a
new
section
for
this.
B
B
Is
that
where
is
it?
Where
does
it
live
commits,
come
on
next
perspective?
Definition,
I,
believe
it
was
this
one
yeah
this
is
it.
A
B
B
A
Right
so
you
can
do
like
this
is
what
we've
been
doing
and
you
can
do
so.
Normally
you
could
do
this
right
and
Define
the
class
and
say:
okay
type
hint
equals
this
value,
and
then
you
could
also
use
it
like
we
wanted
to.
We
wanted
to
use
it
this
way
and
specify
you
know,
name
String,
ID
int
and
provide
default
values,
but
you.
B
Can't
you
can't
really.
A
Do
that
you
can't
like
provide
that
information
to
the
default.
A
You
can't
provide
the
default
value
so,
but
we
can
do
and
then
there's
some
notes
here
about
how
like
it's
using
annotations
instead
of
field
types
well,
so
annotations
is
like
a
built.
It's
like
a
it's
a
it's
one
of
these
types
of
methods
right.
These
double
underscore
methods
that
get
set
well.
This
is
where
things
get
tricky
so
name.
Tuple.
Is
this
class
right
and
you
can
create
it
like
this,
and
it's
got
this
new
thing
and
the
new
I
don't
know
if
you've
seen
the
new
method
before.
A
So
when
we
subclass
new
gets
called,
and
so
then
there's
things
called
meta
classes,
and
so
a
meta
class
defines
how
a
class
works
so,
like
you
know
how
you
can
Define
like
class
methods
and
stuff
when
you
define
a
meta
class,
any
method,
so
not
a
class
method.
Any
method
within
the
clap
within
the
meta
class
becomes
a
class
method
within
the
class
because
it's
essentially
a
class
where
the
instance
of
this
class,
so
a
meta
class,
an
instance
of
a
meta
class,
is
a
class.
A
So
the
instance
of
name
Tuple
meta
is
named
tubble,
and
so
what
we
can
do
here
is
now
we
can
Define
when
the
name
Tuple
class
is
instantiated
like
when
this
definition
here
happens.
A
This
new
method
gets
called
so
we're
creating
a
new
instance
of
that
class,
we're
creating
a
new
type
and
so
name
Temple
meta
classes
are
derived
from
type
because
you're
defining
a
new
type-
and
this
is
I,
mean
this-
is
sort
of
a
lot
of
information.
And
it's
taken
me
a
while
to
get
here,
but
it's
interesting
stuff,
if
you
ever
want
to
go
play
with
it.
The
point
being
here
is
when
you
use.
B
The
new
so
py
type
so.
A
The
type
built-in
function
defines
a
new
class
right
and
we
were
using
this
when
we
were
defining
the
models,
and
so
that
was
down
here
we
create
a
new
type.
We
call
the
name
plus
model
context,
we
say,
derives
from
model
context
and
here's
the
you
know
classed
class
scoped
properties,
and
so
that's
that's
what's
going
on
here
and
we
so
since
the
meta
class
is
a
subclass
of
type.
A
The
new,
the
the
new
function
or
the
new
method
takes
the
class
that
you're
about
to
create
the
name
of
that
class,
the
base
classes
and
then
the
and
then
the
properties
right.
So
you
know
like
this,
so
what
we
can
do
here
is
I
looked
at
this
code
and
I
was
like
okay.
Well,
it's
doing.
This
is
just
a
dictionary
and
it's
just
calling
git.
A
So
that
means
that
when
you
pass
like
when,
when
this
happens
here
when
we
Define
like
an
actual
classic
just
with
regular
syntax
annotations
must
be
the
colon
type
name
thing.
It
must
be
like
an
auto,
prop
Auto
generated
field
for
that
dictionary,
because
sure
enough,
if
this
isn't
just
a
standard
dictionary
like
the
git
method,
has
got
to
be
supported.
Therefore,
if
I
pass
a,
if
we
pass
a
dictionary
with
this
property,
then
it
should
work
and
sure
enough.
It
does
work
so
basically
using
this
code
right
here.
A
It's
like
real.
It's
really
simple
little
bit
of
code
here.
Well,
I
mean
it's
not
entirely
simple,
but
it
it's
it's
a
few
lines
and
it
gives
us
exactly
what
we
want.
I
think
I
might
I
think
we
might
need
to
raise
like
an
issue
in
the
regular
python
bug.
A
Tracker
I
might
go
do
that
for
this,
because
it's
kind
of
seems
ridiculous,
that
you
can't
do
this
by
default,
like
this
is
kind
of
a
stupid
way
to
have
to
do
this,
but
basically
what
we
can
do
now
is
we
can
dynamically
create
name
tuples
with
type
painting
and
defaults,
and
what
that's
going
to
allow
us
to
do
is
simplify
a
lot
of
this
stuff
that
we
did
where
we
were
generating
these
config
methods.
A
A
This
you
know
subclass
of
named
Tuple
based
off
of
the
you
know,
we'll
we'll
create
that
right
and
we
can
generate
it
based
off
of
something
if
we
need
to
like
in
this
psychic
case
or
what
we'll
probably
do
then
is
have
these
config
args
and
config
methods
just
inspect
the
subclass
of
name
Tuple
that
we're
using
as
the
config
and
dynamically
generate
all
this
helper
stuff,
that's
going
to
be
used
to
you
know,
help
ARG
parse
in
the
HTTP
API
communicate.
What
is
that
config
class
that
we're
using
here?
A
So
that
was
probably
like
a
lot
of
dump
information
dump
there.
But
that's
that's
the
plan
going
forward.
The
configuration
is
going
to
get
simplified
is
what
I
think.
A
So,
basically,
because.
B
A
Yeah
so
we
use
this,
but
we
couldn't
specify
type
hinting
and
if
we
can
specify
type
hinting.
That
means
that,
when
we're
doing
the
you
know
so
when
we're
doing
this
ARG
here
and
we
need
to
say
the
type
we
can
grab
the
type
from
the
value
of
the
type
hint
within
the
config
now
does
that
make
sense,
and
that
way
we
can
just
dynamically
generate
the
args
and
config
method
like
we
could
probably
not
have
a
dark,
circumfig
method
like
at
all
anymore,
because
we'll
just
make
them.
A
It's
it's
basically,
just
like
the
config
stuff's
gonna
get
simplified
so
yeah,
because
now
we
have
the
name
of
it:
the
default
value
and
the
the
type
I
don't
know
what
we're
gonna
do
about
help.
We
might
have
some
other
sort
of
dictionary
that
basically
Maps,
you
know
config
things
to
their
help
strings,
but
basically
that
way
we
won't
have
to
like
have
these
arcs
and
config
methods
everywhere.
B
A
B
A
Paste,
okay,
so
this
will
allow.
B
Us
to
Auto
generate
config
and
args
methods,
because.
A
All
right,
sorry,
that's
kind
of
long-winded,
so
we'll
move
the
features
to
config.
We
were
going
to
talk
about
another
thing
with
the
models
weren't
we
oh,
we
should
probably
recap
what
we
talked
about
with
yeah
yeah.
So
you
implemented,
you
did
the
model
not
trained
right.
A
B
The
confidence
as
confidence,
four
models
which
can't
or
which
you
don't
need
to
have
accuracy,
assist
before
they
have
a
confidence.
A
A
For
the
HTTP
API,
things
are
pretty
much.
You
know
rocking
and
rolling
here,
I'm
about
ready
to
push
the
JavaScript
examples,
I'm
going
to
be
doing
that
in
the
next
few
minutes.
Here
sorry
I
know
I
said:
I
was
gonna.
Do
this
all
like
two
weeks
ago,
but
I
I,
there's
been
a
lot
of.
B
Stuff
I
had
to
do
just
just
one
thing
like
yeah
for
the
model
error
stuff
like
but
I,
I
I
didn't
I
I
just
opened
the
scikit
code
after
a
long
time
and
I
didn't
remember
that
we
were
saving
the
confidence,
so
we
were
calculating
it
again
and
again,
like
let's
see
I
can't
remember
either.
A
It
looks
like
we
did
confidence,
it
looks
like
yeah,
we
did.
Confidence
happens
when
we
assess
for
accuracy,
so
we'll
probably
need
to
add
that
little
we'll
probably
need
to
make
this
method
here.
B
Since
confidence
is
returned
when
is
set
when
accuracy
is
evaluated,
we
need
to
have
this.
A
B
A
A
A
So
the
HTTP
API
works
the
same
way.
Basically
we
and
let
me
pull
them
up
side
by
side,
so
we
can
map
python
to.
B
B
Is
we
you
pay
touch
screen.
A
The
first
thing
that
we
do
is
we
well
okay,
so
the
first
thing
you
might
want
to
do
is
list
all
the
models,
so
you'd
say
like
list
slash
models,
Or
List,
slash
sources
and
it
returns
to
you
the
basically
the
result
of
the
args
method.
So
it
dumps
out
all
the
stuff
that
you'll
need
for
configuration.
A
Then
you
take
this
information
and
you
fill
in
the
values
right
so
for
ARG
you
end
up
filling
in.
Oh,
this
probably
needs
an
example,
but
for
ARG
you
do
like.
Actually,
there
is
an
example.
B
A
A
Oh
I
do
have
an
example,
never
mind
sorry.
So
this
is
the
list
of
all
the
things
that
that
you
could
use
as
arguments
right
and
then
here's
an
example
of
using
them.
So
you
say:
configure
Source
this
source
is
a
CSV
source
and
I'm
going
to
call
it
my
data
set
and
then
I
send
this
thing
here,
which
is
the
filled
out
version
using
that
args
information
and
we
say
Okay
so
the
file
name
is
data
set
read
only
is
true
and
then
all
that
stuff
gets
parsed.
A
You
know,
according
according
to
the
way
that
we
were
parsing
it
just
like
the
command
line.
So
it's
just
when
you
type
arguments
on
the
command
line
it
get
parsed
to
this
structure,
so
we
just
use
the
same.
The
same,
the
same
format
here,
we're
going
to
just
send
it
over
and
then
here's
an
example
of
configuring
a
model.
A
You
know
here's
the
directory,
and
it
is
you
know
it's
some
path
to
model
directory
where
the
model
has
been
saved,
then
you
create
a
context
which
is
that
you
know
the
second
async
line,
so
we're
going
to
take
the
plug-in
type
so
like
Source
or
model
the
label,
which
would
be
like
my
data
set
or
my
model
and
then
the
context
label,
which
is
now
like
sctx
or
mctx
right
so
to
create
a
source.
A
There's
no
special
arguments,
you
just
say:
hey
I,
need
to
check
out
one
to
create
a
model.
This
is
where
so.
This
is
why
I
wanted
to
talk
about
the
feature.
Stuff
is
because
to
create
a
model.
When
you
create
the
context
now,
you
have
to
pass
the
features,
which
means
that
this
API
now
needs
you
to
send
the
features
as
their.
You
know,
they're
serialized,
what
what
what
their
representation
in
Json
would
be
right.
A
A
And
then
for
sources,
it's
just
there's!
You
know
you
can
list
all
you
can
grab
one
repo
by
the
key.
You
can
update
the
repo
by
the
key.
You
can
get
all
of
the
repos,
and
this
is
a
you
know.
It
supports
iteration.
A
So
for
training
we
send
a
post
request
with
the
Json
body
being
the
source
context,
labels
that
we
want
to
train
on
so
so
this
would
be
like
my
model
context,
and
then
we
say
you
know
my
training
data
set
is
the
we
created
a
source
for
the
training
data
set.
We
checked
out
our
context
and
we
label
that
context.
My
training
data
set
and
now
it
will
use
that
context.
It
will
go
through
and
say
it
will
do
this
here.
It
will
say
the
model
context
of
you
know.
A
Whatever
that
context
label
we
passed
is
my
model
context,
dot,
train
and
then
it'll
pass
a
sources
object
that
has
my
trainings
data
set
as
the
only
only
member
and
then
it
just
returns.
No,
if
there
was
you
know,
everything
was
okay
and
I
was
thinking
about
you
know
later.
We'll
definitely
want
to
like
have
something
where
it
streams
back
the
logs,
because
it's
gonna,
you
know
be
helpful
and
people
will
like
to
see
the
logs
right.
A
So
we'll
we'll
do
that
eventually,
so
accuracy
we
send
a
post
request
same
same
format.
Only
now
the
response
is
going
to
be.
You
know
the
accuracy
value
is
a
float.
We
give
it
the
source
context
that
we
want
to
train
on
and
then
for
predict.
We
just
send
a
repo,
so
we
send
a
repo
object
like
the
Json
representation
of
a
repo
object,
which
can
be
the
reference
for
that
is
just
like
you
know
up
here.
This
is
what
you'll
get
as
a
repo
object.
A
You
know,
you'll
send
the
same
thing
back
to
update
it,
and
if
you
want
to
predict
it,
you
send
that
same
format
of
object
to
the
predict
URL
here
and
right
now.
The
predict
URL
is
always
just
going
to
end
with
zero,
because
I
didn't
write
the
stuff
to
do
that.
Iteration
support
yet
so
entered
key
is
always
going
to
be
null
and
it's
going
to
do
all
of
them
so
yeah,
and
then
you
get
back
a
repos.
You
know
a
key.
You
get
back.
A
Two
keys
in
the
Json
object,
the
eight
or
key,
which
is
going
to
be
null
for
now
and
then
repos,
which
is
a
key
value.
Mapping
of
source
URL
to
to
the
object
to
to
the
repo
object
with
the
prediction
value
in
it
and
yeah,
and
so
basically
now,
basically,
what
we
need
to
do
is
you
know:
I
have
some
JavaScript
code
that
I'm
going
to
clean
up
here
with
the
new
context
stuff,
because
before
I
just
had
configure
because
sources
didn't
need
to
have.
B
Something
passed
to
it
like
models,
do
with
the
features.
A
It's
gonna
look.
You
know
pretty
similar
to
the
way
that
we
do
things
with
with
the
python,
but
you
know
not
exactly,
of
course,.
B
A
So
basically,
so
this
basically
so
this
function
here,
this
is
just
that
api.js
file,
and
so
this
function
runs
as
soon
as
the
page
as
soon
as
the
page
gets
loaded
like
if
you
start
a
little
HTTP
server
in
that
examples,
web
directory
with
you
know,
do
you
know
about
the
python
simple
HTTP
server.
B
A
Okay
yeah,
so
if
you
just
start
that
in
that
directory
it'll
it
has
this
index
page
and
it
all
it
does
is
include
the
api.js
and
then
you
can
open
up
the
console
and
start
like
messing
around
with
it,
although
of
course,
what
you're
probably
going
to
want
to
do,
is
you
know
you're
going
to
want
to
create
that
react
app,
and
then
you
know
include
this
stuff
as
a
as
a
as
a
you
know,
you're
just
going
to
throw
this
file
in
there
eventually
we'll
want
to
make,
like
you
know
a
whole
npm
repo
for
this,
so
that
it
lives
on
its
own
right,
and
you
can
just
say,
like
you
know,
yarn,
add
this
this
thing
or
the
the
dff
ml
API,
and
that
way
you
could
include
it
in
any
project,
but
for
now
we'll
just
copy
paste.
B
A
Cool
yeah
so
well,
then,
if
she
starts,
if
she
starts
on
it,
I
think
you
know
she'll
probably
be
doing
the
source
stuff.
First
anyways
so
and
you're
gonna
need
the
sources
to
be
configured
before
you
can
go
pass
them
to
the
models.
So
it's
that'll
probably
work
out
fine.
Then
she
has
experience
with.
A
Cool
yeah
I
told
her
that
you
had
that
yeah
she
was.
She
was
expressing
interest
in
that.
So
I
said
you
know
you
have
that
code.
Ed
organ,
maybe
you
would
add
her
as
a
you
know,
as
a
contributor
to
that
web
UI
or
to
the
UI
repo.
If
you
wanted
her
to
just
like
push
to
that
and
get
started
otherwise,
you
know
she
could
do
it
on
her
own
branch
and
you
guys
can
combine
later
yeah.
B
A
A
A
Then
we,
let's
see,
then
we
need
to
also
run
the
dfml
service
HTTP.
B
B
A
B
Star
and
secure
course,
star
Port,
like.
A
B
Wait,
we
go
to
9090
oops
nine
zero
creates.
B
Where
we've
sub
stituted.
B
Port
8080.,
so
that
it
which,
which
is
where
the
API
is
listening.
A
Okay,
yeah
and
so
then
so
we
create
this
API
object
and
then
we
say:
Okay
I
want
this
Source,
that's
going
to
be
my
data
set,
and
then
we
configure
that
source
and
we
point
it
at
my
dataset.json
and
in
between
here
we've
Maybe
upload,
the
my
data
set
dot
Json
file,
and
then
you
know
it
says:
we've
configured
it.
A
Then
we
create
a
new
context
and
we're
going
to
need
to
say,
like
you
know,
my
data
set
context
and
then
we
can
do
things
like
grab
the
repos
and
you
know
then
we
have
like
a
this
is
just
like,
creates
an
array
of
all
the
repos.
A
And
beyond
that,
like
then,
what
we'll
do
is
we'll
have
things
like
you
know,
we'll
have
we'll
do
the
same
stuff,
while
we're
we'll
configure
a
a
so
we'll
create
like
now
we'll
create
a
model.
A
And
so
we
do
like
model
equals
API
dot
model.
My
model
wait.
Oh
yeah.
We
should
probably
say
that,
like
this
is
psychic
model,
so
this
would
be
like
scikit
LR
and
we're
gonna
call
it
my
model,
and
then
we
configure
that
model
and.
A
And
we'd,
you
know
pass
in
the
list
of
sources,
so
we'd
say
like
Source
context
and
that's
pretty
much.
You
know
that
it's
it's
going
to
be
very
it's
it's
basically
like
the
the
API
is
going
to
be
almost
identical
to
the
python.
Api
is
the
idea
right
so
does
this
sound
like?
Does
this
make
sense
and
stuff
I
guess
this.
A
It
the
sources
API,
the
sources
API
is
up,
so
we
I
just
need
to
I
I'll,
clean
up
this
python
code
and
then
I'll
ping,
her
back
because
the
python
code.
Well
so
the
I
think
it
was
I,
probably
miscommunicated.
It's
the
model,
API,
that's
not
quite
up
yet
so
that'll
be
up
as
soon
as
I
update
this
JavaScript
code.
A
All
the
tests
are
running
and
everything
works
and
I
updated
the
documentation,
but
the
JavaScript
code,
which
is
this
file,
which
is
basically
you
know
the
API
objects
and
the
examples
of
how
we
use
them
is
not
up
to
date
right
now,
so
I'm
gonna
update
that
run
the
run
the
CI
on
it
and
then
I'll
merge
this
pull
request
and
then
it'll
be
all
ready
to
go.
So
you
guys
can
just
you
know,
go
ham
on
the
on
the
web.
A
Ui,
but
yeah
it'll
be
I'm
ex
yeah
I'm
excited
to
see
I'm
excited
which
to
see
what
you
guys
do
with
it.
I'm
sure
you
both
are
are
busy
but
and
I'll
obviously
contribute
to
it
too.
But
you
know,
I
wanna,
I
wanna,
see
see
what
you
guys
see.
What
you
guys
come
up
with
before
I,
before
I
jump
in
here
plus
I've
got
like
a
million
other
things.
I
got
to
do.
I've
got
to
finish
this
DFAS
Branch.
B
A
Okay,
it's
empty
I
was
generating
these
so
basically.
B
Like
the
close
444,
this
is
or
not
that's.
A
Nope,
okay,
never
mind
all
right.
Well,
that
I
think
you
saw
all
those
graphs
that
I
was
generating
those
flow
charts,
so
I've
got
lots
more
flow,
charts
generating
now
and
then
the
cool
thing
will
be
that
we
can
take.
Basically,
you
can
take
these
little
operations
and,
like
an
operation,
might
be
like
the
model
train,
stuff.
I've
said
this
a
million
times.
You
know
what
I'm
doing
and
you
can.
A
We
can
make
the
flow
charts
and
then
we
can
stand
it
up
behind
an
HTTP,
API
or
tli,
or
anything
it's
going
to
be
really
fun.
It's
almost
it's
almost
there.
Finally,
so
that's
cool
stuff,
but
so
yeah
you
know,
I
won't
I
won't
be
able
to
jump
on
the
on
the
on
the
web
UI
for
a
little
bit,
but
I'm
I'll
be
definitely,
you
know
have
enough
bandwidth
to
answer
any
questions
that
come
up
so.
B
A
A
A
Yeah
yeah
definitely
well
don't
like
I,
mean
I'm
sure
you're
super
busy.
So
you
know,
do
you?
Don't
you
don't
have
to
feel
like
you
have
to
jump
on
the
meeting?
If
you
don't
want
to
or
like
you
know,
you're
too
busy,
because
I'll
just
post
video
links
and
then
once
you
have
time
again
like
because
an
hour
is
a
long
time
when
you've
got
when
you've
got
a
million
things
to
do
so
so.
B
Are
there
any
more
good
post
issues
like
I
have
bunch
of
people
who
want
to
start
contributing?
Oh.
A
Yeah
so
good
first
issue,
I
think
I
tagged
a
few
recently
because
hacktoberfest
came
around
right.
Let's
see
hacktoberfest
this
one's
easy,
this
one's
kind
of
easy,
the
require
signed
off
by
that's
just
like
a
little
scripting.
This
guy
never
did
this
open,
API
definition.
This
would
be
really
helpful.
B
B
A
B
A
Me
yeah
yeah,
it
is
it.
Is
it's
hopefully
going
to
get
a
lot
a
lot
cleaner
soon
here
so
because
I
think
I
mean
things
are,
things
are
shaping.
Things
are
getting
pretty
clean
here
now,
I
think.
What
we
really
need
to
do
is
focus
on
the
documentation
as
soon
as
I
get
this
DFAS
Branch
done
in
this
model.
Api
now
I'm
going
to
start
documenting
the
hell
out
of
this,
because
I
think
we
have
some
okay
documentation,
but
it
needs
it
needs
to
be
better.
A
Yeah
he
well,
he
hasn't
said
anything
I
mean
he
said
that,
like
on
September
15th,
so
that's
been
a
while
now
I'm,
just
gonna
say
like
if
you
want
to
do
this
I'm
just
gonna
tell
yeah.
That
would
be
great.
This
is
like
I,
think
well,
I
put
the
links
in
there,
but
basically
this
is
like
a
giant
yaml
file
which
just
describes.
A
Basically
there's
they
have
this
inspector
and
if
you
fire
up
that,
so
if
you
down,
if
you
pip,
install
that
that
HTTP
API
and
then
like
point
this
inspector
thing
at
it,
it
should
be
able
to
like
generate
that.
The
file
that
I'm
talking
about
for
you,
I,
just
I,
just
haven't
I,
have
not
used
this
tool
before
I've
used
the
other
side
of
this
tool
which
takes
these
files
and
generates
clients
in
any
language
which
is
really
cool.
But
I
haven't
had
time
to
go.
A
I
would
appreciate
that
and
then
what's
really
cool
about
that
is
where
you'll
generate
you'll
generate
this
yaml
file,
and
then
you
can
create
a
client
in
any
programming
language,
so,
like
all
this
stuff,
that
I'm
writing
by
hand
over
here
in
JavaScript
it'll
just
generate
all
of
this
code,
like
all
of
this
code
here
will
just
get
generated
based
on
that
file
that
you
that
you
write
or
that
you
create
with
that
tool
which
so
you
know
people
could
use
it
from
Ruby
like
it
would
be
great,
so
yeah.
A
A
Cool
that
would
be
great,
yeah
that'll
be
exciting.
It's
I
mean
basically
right.
If
you
just
get
those
three,
the
three
train
predict
accuracy
and
then
like.
If
you
could,
if
you
could
talk
a
little
bit
about
like
the
applicable
features
too,
that
would
be
good,
but
you
know
whatever
you
can
do.
Is
great
I
just
want
to
make
sure
I
just
need
to
make
sure
to
have
all
this
done
by
next
Friday,
because
that's
when
I'm
gonna
go
present
and
so
like
I,
don't
I,
don't
know
how
many
people
are
gonna.
A
Come
to
my
talk,
I,
don't
don't
imagine
it's
going
to
be
a
ton
of
people,
but
whoever
is
there
I
want
to
make
sure
that
when
they
go
and
click
on
the
docs
website,
like
all
our
docs,
look
really
good.
A
A
Yeah
yeah
I
probably
should
have
put
machine
learning
in
the
title.
I'm
at
this
security
conference
and
I
know
a
lot
of
security.
People
are
kind
of
skeptical
of
machine
learning,
so
I
was
thinking
you
know
maybe
I'll,
maybe
I'll
try
to
maybe
I'll
try
to
show
them
machine
learning
after
the
fact,
but
when
I
go
to
the
python
conference,
I'm
definitely
going
to
put
machine
learning
in
the
title.
A
I
haven't
started
doing
that
yet
no,
but
I
tried
to
I
I.
Did
the
podcast
Gades
I
sent
that
one
in
and
I
still
need
to
do
pycon,
but
that's
sort
of
I
think
the
deadline
was
I.
Can't
remember
when
when
was
the
deadline.
B
Icon
us:
what
was
the
deadline?
It.
A
Was
like
it
was
a
little
bit
out
here.
I
know
it
was
after
the
time
when
I
have
to
do
this
talk
I've
got
all
my
deadlines.
You
know
stacked
up
on
me,
December
20th,
okay,
yeah,
so
that'll
give
me
like
a
month
after
I
finish.
This
talk
to
write
the
next
talk
for
this
one
it'll
probably
be
like
you
know,
pretty
similar
in
format.
So.
A
All
right
well,
I
mean
yeah
I,
hope
you
get
that.
That
would
be
great,
but.
B
Other
than
that
so
I'll
just
tell
this
guy
in
case
you're
too
busy
we'll
leave
this
open
for
others
sounds
like
someone
was
interested.
A
Oh,
and
is
your
friend
I
didn't
catch
your
name.
Are
you
on
the
getter
Channel.
B
A
A
good
one
guys
and
good
luck
with
all
your
studies,
I'm
sure
that's
a
lot
of
work
so.