►
From YouTube: Sept 2, 2021 - Ortelius Architecture Meeting
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
B
A
So
let
me
just
start
here,
so
the
service
catalog,
I
just
kind
of
want
to
bring
everybody
up
to
speed
what
we
ran
into
at
the
microservices.
A
So
one
of
the
things
that
when
we
went
through
and
built
the
microservices,
you
know
we
first
started
out
all
the
the
micro
services
were
flask
applications
and
from
there
we
went
from
a
flask
application
to
adding
in
some
additional
functionality
like
a
pie
breaker
to
deal
with
the
connections
issue
when
the
container
starts
up
that
if
we
have
a
bad
database
connection
that
we
go
into
street
tri-logic
using
pie,
breaker
and
then
chrome
added
in
found
some
connection
pooling
through
sql
alchemy,
and
we
added
that
in
and
everything
was
working
great
in
our
local
environment.
A
So,
beginning
of
the
week
we
started
testing.
A
You
know
we
got
the
builds
done
with
the
docker
containers
and
started
testing
the
the
flask
application
with
pie,
breaker,
sql,
alchemy,
all
those
things
and
what
ended
up
happening
was
we
ended
up
getting
these
weird
errors
with
a
conflict
between
the
there's,
a
threading
program
called
greenlit
and
the
threading
program
that
module
for
the
the
unicorn,
which
is
what
we
run
the
flask
application
under
the
docker
container.
That's
like
the
production
version.
The
way
you
run
it
that
required
0.4.17.
A
And
then
the
sql
alchemy
wanted
1.1.1
the
latest
version
and
there
was
no
way
to
kind
of
work
around
it.
As
you
know,
as
part
of
that,
to
get
things
to
work,
so
we
had
to
take
out
a.
A
Takeout
flask
and
go
to
a
separate,
a
different
runtime
environment.
A
So
this
actually
ended
up
being
a
a
kind
of
like
a
blessing
in
disguise.
Fast.
Api
is
200
faster
than
the
the
new
corn
and
the
flask
application.
Also,
the
we
solved
the
version
conflict.
A
So
things
ended
up
being
very
similar
as
far
as
like
you
know,
the
sequel
didn't
need
to
change.
One
of
the
things
that
we
ended
up
changing
was
the
entry
point.
Instead
of
the
flask
being
the
entry
point,
we
have
fast
api,
our
the
pie,
breaker.
We
were
able
to
remove
and
some
of
the
other
modules
that
we
needed
around
the
flask
version
of
it.
This
one
actually
can
come
out
to
the
because
it's
imported
through
the
sql
alchemy.
A
Now
so
one
of
the
things
we'll
see
is,
we
still
have
you
know
getting
the
environment,
the
database
connection,
chrome.
Well,
one
thing
I
needed
to
change
from
the
the
connection
pool
that
you
were
using
was
to
go
ahead
and
use
the
crate
engine
statement,
which
internally
creates
the
cube
tool,
which
is
what
you
were
doing
for
some
reason
it
it
like
built
up
the
the
sql
environment
better
as
part
of
that
process.
A
So
that's
what
we
ended
up
having
to
to
do
on
that
level
from
the
database
perspective,
one
of
the
things
with
the
fast
api
is
we
can
set
up
classes
of
what
the
returned
objects
look
like.
So,
in
the
case
of
the
health
and
the
health
endpoint
that
we
have,
we
can
actually
list
the
responses,
and
this
is
where
our
swagger
documentation
actually
is
being
defined.
Now.
A
So,
if
we
look
at
the
the
health,
we
basically,
you
know
our
description.
Our
examples,
those
type
of
things
are
all
based
on
are
going
to
be
pushed
over
to
swagger
and
swagger
is
internally
built
into
fast
api,
which
is
the
other
part
that
we're
able
to
remove
up
at
the
top.
We
used
to
have
a
swagger
piece
importing
some
of
the
swagger
ui
and
setting
up
some
of
the
swagger
information.
A
So
I
just
ended
up
moving
some
of
the
swagger
details
out
of
this
swagger.yaml
over
into
the
code
here
itself.
One
of
the
good
things
on
that
front
is,
you
know
all
everything's
in
one
place.
So
if
you
change
or
add
a
response
that
you
can
just
change
it
in
the
code,
you
don't
have
to
go
to
the
swagger
file
and
and
do
it
in
two
places.
A
So
our
health
connection
it
used
to
be
a
class,
was
the
end
point.
So
this
is
where
we
define
the
endpoint
here
and
in
the
past
it
was
a
class,
and
instead
we
just
made
it
over
to
an
async
you'll,
see
in
the
fast
api
documentation
that
you'll
have
different
parameters
that
you
can
pass
into
the
function.
So
you
can
get
access
to
specific
parts
of
the
work
of
the
underlying
like
http
model,
so
in
this
case
we're
interested
in
the
response
part
of
the
code.
A
So
the
response
part
because
we're
going
to
go
ahead
and
set
like
the
return
code.
So
basically
one
of
the
other
things
that
we
I
found
this
was
late
last
night
was
we
needed
to
use
a
with
statement
for
doing
our
queries.
The
with
statement
in
python
does
some
interesting
things.
A
So
when
you
specify
a
width-
and
you
can
do
this
like
with
files
and
other
things,
basically,
when
you
end
up
going
out
of
scope,
it's
like
a
built-in
tri-finally
type
of
world,
that's
there
and
when
it
goes
out
of
scope,
it'll
go
ahead
and
do
what
it
wants
to
do
as
far
as
like
close
interconnection
closing
cursors
those
type
of
things.
A
So
that
was
one
of
the
the
nice
things
that
I
found
that
we
needed
to
use
with
the
the
new
connection
pooling
instead
of
the
the
explicit
connection
pulling
that
crumb
set
up
the
more
the
implicit
one.
What
was
happening
in
the
previous
iteration
of
the
database
connection?
It
would
do
this
weird
if
you
let
it
be
idle
for
like
five
minutes,
and
then
you
try
to
throw
a
transaction
at
it.
A
It
would
go
and
and
say
that
this
connection
rollback
was
already
closed
and
it
was
like
the
connection
pulling
was
all
confused
and
I
think
what
was
happening
was
we
weren't
explicitly
closing
all
the
connections
and
cursors
in
the
right
order,
so
this
with
syntax
kind
of
solves
that
for
us
and
also
simplifies
the
code
dramatically,
so
keep
going
here
so
like
on
here.
We
could
actually,
after
this,
it's
not
not
necessarily
a
a
mandatory,
but
we
could
do
a
cursor.close
here.
A
This
will
actually
happen
once
we
go
out
of
the
scope
of
the
with.
So
that's
one
of
those
things
that
it
kind
of
helps
us
with
the
the
clean
up
process.
A
Here
we're
gonna,
go
ahead
and
return
our
status
with
the
op
and
service
name
now,
you'll
see
with
the
response
that
were
we've
set
up
here.
Let
me
get
rid
of
this
at
the
bottom.
You
see
it
all
on
one
page,
so
we
have
our
status
message
and
our
status
message
is
associated
to
the
model
and
when
we
return
a
200
which
is
a
okay,
that's
going
to
be
the
format
of
the
json
going
back.
So
this
is
where
we're
just
doing
a
normal
return,
everything's
good.
A
So
that's
where
we
have
our
status,
which
corresponds
up
to
here,
and
we
have
our
service
name,
which
corresponds
up
to
here,
and
this
is
how
you
do
it
optional.
It's
it's
a
little
bit
of
a
weird
syntax,
but
it
definitely
works.
So
this
is
saying
service
name
is
an
optional
string.
A
If
we
have
a
down
message,
what
we're
going
to
do
in
this
case
we're
setting
the
status
code
to
say
that
the
service
is
unavailable
and
then
we
go
ahead
and
do
the
the
same
return
and
same
with
the
if
we
catch
an
exception
like
with
the
database
or
any
basically
any
exception,
we're
to
go
ahead
and
return
the
down
message.
A
A
Alrighty,
so
for
validate
user.
This
is
one
of
the
other
entry
points
in
this
one.
Basically,
it
returns
a
list
of
integers
of
the
of
the
domains
and
that's
optional,
but
what
we're
going
to
do
is
return
an
empty
list
just
in
case
there's.
If
we
don't,
if
we
don't
have
anything
if
it's
not
like
ask
for
we'll
go
ahead
and
just
return
an
empty
list
as
part
of
that
process,
so
this
is
the
domain
model
that
corresponds
up
to
here.
A
Same
thing,
we're
actually
gonna,
have
you'll
see
here
we
just
have
a
regular
message
class
just
for
some
authorization
failure
messages
same
type
of
thing.
The
examples
here
is
the
function
for
validate
user
for
the
get
you'll
see
that
we're
bringing
in
the
request
this
time.
Instead
of
the
response.
A
Also,
we
have
an
optional
string
called
domains,
and
then
this
is
replacing
the
validation
that
chrome
was
using
with
webargs
res
fast.
Api
has
the
validation
in
place.
So
this
is
just
a
simple,
regular
expression,
but
we
do
have
the
capability
of
doing
more
complex
validation
if
we
want
to
so.
Basically,
this
is
just
checking
to
see
if
it's
a
uppercase
or
lowercase
yrn
coming
in
as
a
parameter
and
that
one
is
optional,
then
we
go
through.
In
this
case
we
are
double
checking
our.
A
This
is
the
validating
the
the
token
that
was
coming
across
from
the
login.
So
here
we
actually
go
and
get
from
the
the
request
we
have
access
to
the
cookies.
We
grab
the
cookie.
The
the
token
call
the
cookie
called
token
do
our
jwt
stuff
and
start
returning
our
return
codes.
A
Now,
if
something
fails,
one
of
the
things
that
you
do
to
bail
out
is
you
raise
an
http
exception
and
you
give
it
what
you
want,
and
the
message
so
you'll
see
that
coming
into
play,
when
you
want
to
bail
out
is
part
of
a
function
in
the
health
one.
It
was
a
little
bit
different
because
we
didn't
really
want
to
throw
an
exception.
We
just
wanted
to
tweak
the
status
code.
A
So
that's
how
come
in
the
health
check
it's
a
little
bit
different.
Finally,
we'll
get
into
our
connection,
so
we
we
create
the
connection.
The
same
way
do
our
queries,
trying
to
figure
out
if
the
user's
validated
get
if
the
domains.
If
they
pass
in
that
yrn,
then
we
do
additional
query
to
go
ahead
and
return
the
domain
list,
and
then
we
return
our
result
as
part
of
that,
one
of
the
things
that
you
do
need
to
be
aware
of
is
you
need
to.
A
One
of
the
weird
things
I
ran
into
in
the
testing
is
because
exception
is
generic
when
you
do
the
the
raise
up
here
of
the
exception,
and
it's
in
a
separate,
try
block
this
one
here
will
actually
catch
that
one
up
there
and
you
won't
return
from
the
the
the
method.
A
So
what
you
have
to
do
is
you
have
to
catch
the
http
exception
from
above
and
re-raise
it
basically
as
part
of
that
process
again,
the
auto
close
and
all
that
stuff
is
going
to
happen
for
us
here
we're
explicitly
closing
the
connection
as
part
of
the
process.
That's
one
thing
we
can.
We
can
do
it's
not
required
to
close
it
up,
but
this
the
with
the
with
statement,
will
actually
take
care
of
all
that
for
us
as
per
that
process.
A
A
So
if
we
want
to
run
it
basically,
oh
it's
uv
corn.
It's
probably
hard
to
see
on
my
with
my
font
and
stuff,
but
it's
uv
corn,
the
python
file,
then
the
app
name
and
then
the
port
number
you'll.
It
listens
on
127.0.1.
A
A
So
that's
running
outside
of
the
container,
and
if
we
go
ahead
and
refresh
we
get
our
that's
our
health
status,
we're
up.
That's
our
service
name.
If
we
want
to
look
at
the
docs,
we
just
flip
over
to
docs.
A
And
we
get
our
our
swagger,
it's
basically
open
api
with.
So
this
is
the
health,
the
examples
that
we
had.
So
this
part
here
is
coming
from
this
part
here.
A
So
that's
where
the
swagger
is
getting
getting
picked
up
at
that
level.
Whoops
go
back
over
here
and
then
our
down
message.
If
you
want
to
look
at
the
validate
user,
it
gives
us
a
query
with
the
the
parameter
kind
of
the
regular
expression.
What
is
expecting
our
example
for
success
example
for
the
failures
and
then
we
can
actually
get
into
the
the
schemas
themselves.
A
A
Have
a
little
more
flexibility
and
a
little
a
little
cleaner
code
than
on
the
flask
side,
some
of
the
requirements
files
for
this
one
because
it
uses
jwt
the
cryptography
and
the
jwt
are
actually
coming
from
base
image
and
same
with
fast
apis.
I
mean,
and
the
reason
why
these
are
coming
from
the
base
image
is
they
are
need
the
gcc
compiler
installed
to
install
those
modules.
A
So
if
you
look
at
the
docker
file,
we're
pulling
it
from
a
base
that
we
built,
and
basically
you
just
go
ahead
and
set
up
any
of
the
environment
variables
to
pass
across.
These
are
the
defaults
and
then
copy
your
main.
Your
requirements
install
it
and
they're
up
and
going.
If
you
look
at
the
base,
you'll
kind
of
see
what
I'm
talking
about.
A
A
So
we're
bringing
in
alpine
38
this
is
on
docker
hub.
We
use
it
as
the
the
base
builder.
A
A
We
just
create
a
working
directory
that
we're
gonna
go
ahead
and
install
the
modules
into
at
the
os
level
we're
going
to
install
the
the
python,
the
postgres
development
library,
all
the
compilers,
the
python
development
library.
Some.
I
can't
remember
what
this
one
is,
and
this
one
is
a
cryptography
library.
A
Once
that's
done,
we
copy
those
from
the
install
directory
into
local
and
then
we
go
ahead
and
add
a
postgres
library
that
we
need
to
add
in
for
the
runtime
and
then
we
just
echo
nothing
to
the
a
startup
file,
so
that
kind
of
gives
us
what
we
need
as
part
of
that
process.
A
A
I
want
to
thank
karam
and
utkarsh
for
working
on
it
and
putting
up
with
me
with
changing
things
around
kind
of
been
jumping
all
over
the
place
on
this
trying
to
figure
it
out,
but
it
didn't
really
come
into
play
until
we
started
testing
under
the
docker
kubernetes
world.
You
know
we
didn't
really
see
any
of
that
until
then.
D
D
A
Yeah,
it's
there's
not
that
many!
You
know
the
the
bulk
of
the
code
is
the
same.
You
know,
like
our
queries,
are
the
same.
It's
just
reworking
some
of
the
understanding
that
you
need
to
move
some
of
the
docker
over
into
I
mean
the
swagger
over
into
the
the
code
base.
One
thing
this
is
one
of
our
other
microservices
that
you'll
see
it's
very
similar.
We
have
all
the
the
health
checks
and
stuff
like
that.
Those
are
identical.
A
A
This
took
me
a
while
to
figure
out,
so
the
body
allows
you
to
have
access
to
the
basically
the
json
body,
and
you
tell
it
you
want
to
be
a
dictionary
in
the
case
of
the
safety
one
the
safety
gets
sent
across
as
a
list
as
per
that
process.
Let
me
see
if
I
have
this
one.
B
A
B
A
Oh
so
that
you'll
see
where
it
came
up
on
127
and
it
won't,
let
me
have
access
to
it.
So
that's
what
I
was
saying
with
the
host.
You
have
to
pass
in
dash
dash
host.
A
All
right,
we
should
be
able
to
see
it
now,
so
I
just
was
starting
up
the
another
one
of
our
micro
services
and
I
left
off
the
zero
zero
host
and
what
ends
up
happening
is
when
I
hit
the
ip
address
it,
it
says,
can't
be
found,
so
you
have
to
pass
in
that
the
the
zeros
in
order
to
expose
that
over.
A
So
here's
the
the
the
post
for
the
json
and
you
can
see
the
example
file,
so
this
is
actually
a
file
that
we
load
in
at
execution
time.
So
it
gives
us
a
nice
full
example
of
what
we're
expecting.
So,
not
just
like
something,
a
small
snippet
that
you
put
together,
it's
a
real
example,
which
is
nice
and
you'll,
see
for
safety.
A
It's
an
array,
an
array
of
rays.
I
don't
know
why
they
did
it
that
way,
but
that's
the
way
it
happened.
A
So
if
you
need
help
getting
moved
over
to
you
know
karam
and
ukarshire
working
on
flipping
these
over
to
fast
api.
Just
let
me
know
if
you
run
into
anything,
I
can
point
you
in
the
right
direction.
Pretty
quick!
I
think
I
got
a
handle
on
what
we
need
to
do
at
that
level.
D
A
Yeah,
it
definitely
simplifies
it.
There
are,
like
I
said,
a
few
little
differences
with
the
using
like
the
width
statement
for
blocking.
You
know
scoping
the
the
sql
queries,
but
once
that's
in
place
it,
it
looks
good.
D
A
Yeah-
and
I
thought
we
were
you
know
that
was
a
an
easy
way
to
start,
and
you
know
it
was
you
know:
flask
is
pretty
popular,
but,
as
things
evolved
once
we
got
into
running
things
in
the
docker
container
that
part
of
it,
I
would
have
to
say
kind
of
like
docker
and
flask,
don't
necessarily
play
well
together,
and
it
just
has
to
do
with
the
way
the
flask.
A
The
way
it
seems
is
like
flask
kind
of
expects
you
to
be
running
like
on
a
vm
and
not
really,
because
you
have
to
put
other
pieces
in
place
like,
like
a
nginx
front,
end
proxy
and
a
couple
other
things
to
make
it
production
ready.
And
when
you
look
at
it
at
the
docker
level,
things
are
trying
to
be
all
those
different
pieces
were
fine
trying
to
be
shoved
into
one
container
and
it
just
wasn't
working
cleanly.
A
So
I
think
the
f
from
what
I
could
tell
the
last
couple
days
is
the
fast
api
implementation
seems
to
be
tailored
more
for
a
production
environment.
D
Yeah
from
the
code,
it
seems
the
same
like
we
in
springboard.
We
also
have
the
same
thing
like
we
get
all
these
query
parameters,
all
those
things
from
in
the
method.
Only
the
endpoint
url.
It
is
getting
back
to
the
same
method
and
you
up.
You
can
apply
the
validation
directly
at
placement,
so
nothing,
nothing
like
we
used
to
do
in
the
last
part
like
we
should
write
another
piece
of
code
inside.
B
A
Right
and
since
the
last
the
last
meeting,
that's
where
we
had
a
a
a
pretty
big
shift,
so
I
will
help
you
with
the
the
the
fast
api
part.
What
I'm
going
to
do
is
I'm
there's
a
couple
other
microservices
that
we
need
to
have
updated
arvind
that
aren't
on
the
critical
path.
So
I'm
going
to
work
with
you
and
those
getting
those
up
to
converted
from
flask
over
to
fast
api.
A
Yes
there,
when
we
made,
let
me
share
my
screen
a
little
bit
real,
quick.
A
So
this,
like
this
one,
we
we
need
to
copy
in
some
additional
files,
so
it'll
be
a
little
bit
of
work
depending
on
your
the
application
working
with
docker,
but
as
part
of
the
whole
process.
A
You
want
to
be
able
to
do
a
docker,
build
and
run
your
your
microservice
locally.
You
know
to
get
it
to
get
it
to
start
up
and
make
sure
that
you're
not
getting
any
like
weird
dependency
issues
and
stuff
like
that.
So
what
you'll
need
to
do
is
go
ahead
and
build
locally
the
docker
image
and
then
just
start
it
up
to
make
sure
that
you're
not
getting
any
unresolved
modules
and
the
unresolved
modules
come
into
play
with
the
requirements
file.
A
So
when
we
do
the
the
updates,
there's
basically
three
files
that
you
need
to
update
the
main,
the
requirements
and
the
docker
file
and
then
actually
there's
gonna
be
a
fourth
one
which
will
be
the
the
cloud
build
yaml
file.
A
That's
where
we
actually
do
the
builds
up
on
google
and
from
there
we'll
actually
need
to
once
we're
done
with
that,
get
the
charts
cleaned
up
and
ready
to
go.
So
that's!
Where
kind
of
where
we're
at,
like
I
said
the
next
step
will
be
in
the
the
charts
world
for
the
helm,
charts
to
make
sure
we
can
deploy
everything
to
the
kubernetes
cluster
correctly.
A
And
what
I'm
going
to
do
is
I'm
going
to
unassign
you
from
one
issue
and
assign
you
to
a
couple,
others
that
will
be
a
little
bit
simpler
for
you
to
work
on
since
you're
new
to
the
coding.
A
All
righty:
this
is
a
reminder
there
we're
gonna,
be
meeting
this
afternoon,
my
time,
4,
30,
mountain
time,
8,
30,
australian
time,
8,
30
a.m,
australian
time
for
the
get
ops
with
brad
and
I'm
at,
and
I
think
we
may
have
adam
gardner
join
us
and
a
couple
of
other
new
folks
from
that
side
around
the
get
ops
from
there
we
will
be.
A
A
A
The
base
model,
I
think
what
I
found
is
the
base
model.
Let
me
show
you
what
we're
talking
about
here.
A
So
the
base
model-
I
think
that
is
used
by
that's
a
rest
api.
Oh
it's
coming
from
pandanic,
it's
just
how
we're
importing
the
pydantic
syntax
is
being
inherited
from
base
model.
A
So
what
this
does
it
allows
you
to
kind
of
in
in
python?
You
really
don't
have
variables
that
you
assign
a
specific
type,
so
you
can
take
a
variable
x
and
you
can
assign
it
to
be
equal
to
one
and
x
will
be
treated
as
an
integer,
but
then
in
the
next
second
next
line
you
can
say
x
equals
a
and
it'll
convert
the
variable
over
to
a
string.
A
Then
the
pythagoric
is
trying
to
give
a
type
to
a
a
variable
that
allows
for
validation
and
transformations
on
the
fly
from
like
json,
and
things
like
that.
So
these
that's,
where
the
base
model
and
the
pythanic
is
coming
into
play,
kind
of
giving
you
a
type
for
the
what
you're
looking
for.
I
don't
know
on
this
line
of
karsh.
A
If
you
can
the
model,
if
it
can
be
something
other
than
a
class,
if
it
can
be
a
dictionary,
I'm
pretty
sure
that
in
the
fast
api
that
it
has
to
be
a
a
class
definition,
I
hope
that
answers
your
question.
A
A
So
that's
a
good
question
on
so,
for
example,
like
the
status
message.
So
what
what
carson's
question
is
is
it
does
it
make
sense
to
re
repeat
the
definition
of
status,
mesh
message
for
every
single
microservice
and
the
same
thing
goes
with
like
the
health
check,
so
what
it
really
we
need
to
kind
of
make
a
decision
is
something
like
this
that's
kind
of
like
reused
across
all
of
the
microservices.
A
If
we
should
move
that
into
a
python
module
and
then
import
it
at
that
level,
do
an
import
and
set
it
up
that
way.
So
it's
we.
If
we
need
to
fix
it,
we
fix
it
in
one
place,
but
then
we
just
go
and
rebuild
everything
to
consume
it.
So
that's
one
thing:
one
question
that
we
need
to
look
at
is
from
a
reusability
standpoint.
How
much
do
we
want
to
go
get
into
creating
additional
smaller
utility
libraries
or
modules
any
thoughts,
if
you
guys
are
willing
to
stick
around?
D
A
Right,
you'll
still
have
to
add
a
couple
lines
we
can
make
it
pretty
generic,
but,
like
I.
D
A
D
We,
if
you
can
like
define
a
properties
file
and
let
define
the
service
name
in
the
properties
file
and
the
model
can
pick
it
up
from
there.
That
would
like
simply
pulsing.
A
Yeah
so
because
there's
like
the
health
check,
there's
another
one,
let
me
go
over
to
this
there's.
The
validation
like
like
here
this
code
is
repeated
in
every
microservice,
where
we
go
in
and
validate
the
user
ids.
This
could
be
another
method
that
we
just
import
from
a
utility
standpoint.
So.
A
Those
these
are
the
two
that
I
found
so
far
that
are
pretty
common
across
well
there's
and
then
the
one
last
class
just
message.
So
message
is
for
the
the
errors.
A
A
You
know
put
end
up
putting
all
this
business
logic
and
stuff
in
a
shared.
You
know
python
module
that
really
it
shouldn't
be
there.
So
that's
one
thing
we
just
have
to
keep
an
eye
on
at
that
level.
D
A
Exactly
well,
that
will
be.
That
is
actually
what
this
class
that
we're
looking
at
this
microservice
does
it
keeps
track
of
those
dependencies,
so
ortelius
will
actually
keep
track
of
the
dependencies
for
us.
A
A
A
And
if
you
look
at
like
this,
is
I
have
to
go
and
rename
this,
but
basically
this
is
the
command
line
interface.
The
package
is
named
and
I
gotta
rename
it
to
ortulius.
A
A
A
D
And
what's
the
form
like
the
format
of
this
particular
arctic
effect,
like
the
build
that
we
create.
A
A
This
is
where
you
get
to
set
up
the
project:
urls
the
author,
the
packages
any
binaries
that
you're
going
to
create
this,
this
one's
like
optional,
your
license.
A
Your
long
description,
which
comes
from
your
your
documentation,
this
is
what
everything
and
and
then
what
you're,
what
you
require
for
the
install.
A
A
Yeah,
it's
a
special
zip
file
format
that
is
used
because
what
ends
up
happening
is
oops.
Let
me
see
there
we
go.
A
So
you
can,
the
format
is
set
up,
so
you
can
run
a
pip
install
and
I
think,
on
the
back
end,
that
on
the
pi
pi
side,
these
are
tgzs
the
way
they
get
stored.
A
So
when
we,
what
ends
up
happening,
is
they
it
ends
up
being
just
like
any
other
python
module.
You
can
do
your
import,
you
can
do
your
pip
install
all
those
things.
It'll
act,
just
like
any
of
the
other
python
modules
that
are
out
there
they're
once
you
there's
just
a
specific
directory
format
and
setup
that
we
need
and
from
there
you're
good
to
go.
A
A
There's
the
bin
directory,
so
here
is
the
actual
module
itself
and
in
it
is
a
couple
files.
You
have
a
an
init
which
is
basically
a
just
like
a
placeholder
to
say
that
this
is
a
module
and
then
the
the
the
pyc
is
the
compiled
version
of
that
and
then
here's
the
actual.
A
Module
itself,
basically
it's
you
do
your
your
java,
it's
like
javadoc,
but
it's
python,
doc.
B
A
You
can
do
your
your
your
doc
inline
in
the
code
and
then
there's
ways
to
export
it
and
create
markdowns
automatically
from
your
code.
A
So
you
do
your
imports
and
then
you
just
have
your
definitions
so
like
this
one
is
being
exposed
and
here's
the
arguments
kind
of
like
just
like
in
javadoc
what
you're
looking
at
as
parameters
and
your
return
and
things
like
that.
So
that
all
is
where
it
comes
into
play,
there's
a
little
bit
more
to
creating
a
python
module
than
like
the
flask
or
the
fast
api.
Just
because
it
requires
more
documentation
because
it
wants
every
single
method
or
function
documented.
A
So
you
end
up
with
your
your
python.
Markdown
comes
in
pretty
handy,
you
know
it's
it's
trying
to
give
you
the
the
self
documentation
from
the
from
the
code
base.
A
So
ours,
you
know
the
ours
won't
be,
and
here's
like
the
distribution
directory-
I
don't
know
they're
called
wheels
in
the
python
world
and
I
think
it's
just
like
another
form
of
a
tgz
format,
but
basically
it's
packaging
it
up
in
and
you
upload
the
wheel
to
pi
pi
then
through
through
using
twine.
A
Let
me
know
if
you're
I'll
get
us
started
and
then
I'll
help.
Whoever
needs
wants
to
work
on
that
stuff.
What
you
need
to
do,
there's
a
couple
command
line:
programs
like
the
pi
dock,
markdown,
there's
twine,
there's
the
setup
program,
there's
a
bump
version,
so
there's
a
bunch
of
little
things
that
you
need
to
kind
of
have
in
place
to
run.
In
order
to
do
everything.
A
A
Any
other
questions
that
lucas
does
that
answer
your
question.
A
Well,
thank
you,
everybody
for
hanging
on
for
the
extra
half
hour
and
we'll
keep
plugging
away
I'd
like
to
try
to
wrap
up
the
microservices
this
week,
so
we
could.
A
Actually,
we
know
that
we
are
all
you
know,
or
at
least
by
by
monday,
that
we
know
that
all
the
the
microservices
are
running
incorrectly
in
the
docker
containers,
and
then
we
can
go
to
the
next
step
of
getting
all
of
our
helm,
charts,
updated
and
pulled
pulled
together
that
last
piece,
so
that's
kind
of
where
we're
at
on
the
the
project.
So
thank
you,
everybody
for
all
your
hard
work
on.