And welcome to another intermediate python tutorial.

In this tutorial, what we're gonna be talking about is a sink io or sink, Yo, depending on which way you want to say it, I won't judge other people will, Uh And what a sink iose for is for a synchronous programming.

And probably the best way to thio kind of understand concurrency.

Um, in basically any programming language is it's often confused with doing something in parallel.

It's kind of like you're handling maybe multiple things in parallel, but you're definitely not doing them.

You might.

You're aware of them in parallel, I suppose.

But you're not doing them in parallel.

So, for example, like, let's say you're you're out for a jog and you feel like a little tap on your shoe.

You look down, your shoe's untied.

Do you have to finish your entire jog to tie your shoe?

I hope not, Right Like that would be That would be unsafe to your very unpleasant and unsafe at the same time.

Eso No, you stop your run, you suspend your run and you bend over entire shoe.

You finish tying your shoe and you get back to your run, okay?

And this is your doing these two tasks.

What right to your able to tie your shoe and you're able to run concurrently.

So the same thing is true with programming like, let's say, you got a Web page, and that Web page needs to load a whole bunch of elements.

But, you know, as it's going down the page and it gets to some image that it's requesting from some server, that server just is not responding.

What happens?

Well, if your pages loading synchronously where your entire Web page will hang.

But if your page loads a synchronously, then the other elements are going to get to load.

And you may or may not ever love that image.

Maybe that servers down or something.

But if it's just taking a long time while you have that Leighton see between the the io had hence a sink, I owe input output.

While you have that delay, you could be doing other things other than just sitting there literally doing nothing and waiting on, um ah, response.

Now, um, what I'd like to do here is, um, just I think we're just gonna start with a really basic function, and then we're gonna turn it into, um ah ko routine.

If I say go routine in this tutorial.

Forgive me.

Um, my first experience with concurrency was actually with go routines and go, and so I just call it co routines.

Go routines.

You might not even notice.

Anyways, um, let's just say this is the function that we're going to use, So all it is is it's just gonna find some numbers.

And by the way, yes, I'm just I just copy and paste to this function.

Um, e I'll put a link in the description to the text based version, and you can get it.

Grab dysfunction where you can write it as I'm talking if you want.

But basically, the idea of this function is to just in any range we're gonna divide by something.

So, uh, then what we're gonna do when we start the function is we're gonna print out what we're doing.

What's the range?

Was the divx by?

We're going to start a located.

So anything in that range, that's ah, basically, that's divisible by whatever r div by is, we're gonna add that and then when we're done.

We're gonna have a little thing that says we're done, and it returns.

Whatever we located now to run this, um, I'd probably just put it in a block.

But for the purposes of this tutorial, we're gonna go ahead and we'll use Define.

Um, we'll just have a main main function here, and we'll just say dibs.

One equals.

And let's just, uh, copy and paste that and that will be just so I match the text based right up.

Let's do 50 8034 1 1133 and then I'm just gonna copy.

Paste paste.

Make that 23 uh, 1050 to 30 to 10 and then we'll do 500 three.

Okay, so now we've got our main function here.

And then, um, just for in case someone wanted to import this amazing script of named equals main, we would have just let's just run the main function.

So, um, so with that, you also you know, you can change this function to be anything you want.

You can you can have it doing Ah, Fibonacci stuff.

If you really want to be like everybody or he could do, Um, anything you want.

Really?

I will say, if you are interested in doing truly http, eat tasks, you can look into a Iot HDP for doing a synchronous requesting and stuff like that.

So that's why we're not going to use that for this example.

But just take notes.

So, uh, now that we have this does want to, um what we want to do is we could even let's just run this real quick.

Just see what we're dealing with.

So as you can see, this whole script runs.

It's about 0.3 seconds, and we can see it runs in the order that we called it.

Basically So runs dibs.

One it finds it just starts iterating through 508,000 finding all instances where we have a number that is divisible by 34,113.

So it does this one and then it does this one, and then it does, uh, this one.

So what could we do to convert this to be a synchronous?

And why might we want to do that?

Well, for example, what if this was instead this right?

And we ran this?

It's gonna hang on this one where we actually really could have found the answers to these two and then come back to this one and spent aboutthe same amount of time, right?

We didn't have to waste all this time still waiting on this one, right?

And so So that's kind of what we're trying to solve.

We're trying to figure out a way that we don't need to do this.

And we'd ideally not like to use something like threading or multi processing if we don't have to, because that ads in a whole slew of other things that we might may or may not be interested in dealing with.

So, uh so So at this point, this program is totally synchronised.

It runs in order and all that.

And now what we want to do is begin to bring this, uh, Thio, bring a sink.

Io into this summer's gonna bring over the documentation again In the text based version of Suit Auriol.

I do put a Lincoln here, but as you can see, this is a pretty large package.

So there's a lot going on here.

In my opinion, I always wish in the standard docks they would have like a you know, stupid, simple section, right?

Just first, like super basics.

And then you could go through this stuff is that's basically what we have to do every time we find something we have to do.

Like a really simple example.

Uh, and then and then we can.

And then we could maybe come to the docks and see what?

What can we tweak and change and all that, But anyway, there's a whole bunch there for you is basically an a p i over concurrency that you really could use yield from.

You could use the go code routine decorators and stuff like that, and you wouldn't necessarily.

You don't have to use a sink I owe to do concurrency.

It's just it's a very large package to help you do it.

So anyways, getting back to the code, How do we convert something to being a synchronous?

Well, first of all, the main conversion is rather than deaf.

Something you a sink death something.

Um, and that basically notifies python A.

This is a co routine.

So the first step that we're gonna make is actually we're just gonna a sink both of these functions now Uh, the next thing that we want to do is we want to go ahead and bring lips.

We're gonna bring in, um, import a scene guy.

Oh, that way we can use some of these like, helper helper functions, basically with a sink.

Io.

So now what we want to go ahead and do is once you have your co routines, we need some sort of loop, right?

Right now, we're just running main and in theory, main itself.

You would call this at the moment?

Probably a main loop just because it's gonna run through that little block of code.

But what we want to do with a sink Iose we need to establish the main loop, which is kind of it's basically your event loop.

And then you were gonna add in tasks and tell that loop how to run and all that.

So so now we're gonna do is we're gonna come down here, and this is where we're gonna stuff in the least the initial definitions for loop.

So we're gonna say loop equals a sink io dot Get underscore Event blue.

So this is just gonna initialize our loop for us, then what?

We want to dio is we basically want to run the main co routine, Uh, until it's done.

So the way that we're gonna do that is we're just going to have its just its loop dot run, run, underscore until underscore complete main.

And again there's there's, like, run things run forever.

Yes, right here in the documentations.

Uh, yeah, you could run forever.

You could run until complete.

And then there's all kinds of checks that we can do.

We can get status and all that.

So again, there's no way I can cover this entire package in one video.

Um, or even a few videos just know the docks exist, So so anyways, run until complete.

And then whenever you're done, um, you can you do a loop dot clothes.

I'm actually not 100% confident.

Run until complete is gonna require a loop dot clothes, but we'll go for it also, you'll see a lot of times in code, it's going to try to do the loop stuff except do some logging, not really a pass.

And then finally, you're gonna loop dot clothes because you always want to close off that loop.

This is telling me is Brian Griggs.

Don't do anything too, Okay.

Exception has he?

How about that?

You don't like the exception?

Cool.

General exceptions.

OK, Anyways, um okay, so So now we've done s We've got the loop.

Now we have to do is we need to insert stuff into that loop.

So all it's gonna do right now is we're on the main core routine.

Okay, but the co routine is running.

Basically, these functions still synchronously, right?

It still says just run 12 and three instead we want to do is we're gonna add them in.

So rather than find divisible sze, we want to say, rather than just running just that function, we actually wants a loop dot Create underscored task.

Take three.

There we go.

Run that.

So now I'm just gonna add this bang bang, bang bang.

And now we've created the task in the loop toe, actually, run these three things now.

I'm trying to think I think I think this is Runa below at this stage, let me just run quick, see if we had there.

Yeah, okay.

It is Okay.

So it is run noble at this stage, but we have a couple of issues.

The first thing is, any time you you send off a co routine to run, you want to make sure you wait for the code routine to finish, especially if you're gonna start in a loop or if you're gonna end your code.

So if you're just if you're writing a script that happens to use a stinky Oh, if you happen to need to do that, you want to make sure you've waited for the results before you end this script, Um, or but again in the loop, especially if you don't wait, you're gonna you're gonna really quickly dispatch a lot of code routines.

So So what do we need to do?

We need to await.

So we await pretty much you're gonna await batches or single co routines trying to think if I'm gonna say something wrong here, but I'm trying to have an instance where you wouldn't want to eventually await your co routines.

If you can think of one, let me know.

I'm sure there's gotta be something, but anyways we want, especially if you want the least.

If you want the results, you're gonna need to wait for it.

You're just trying to dos somebody.

I guess you don't need to wait for it.

So anyways, ah Ah, wait.

And then we're gonna sink.

Eo, I gotta stop saying thank you.

I'm going to get stuck saying it now.

Uh, dibs.

One dibs to I see my type of dudes.

Three interested.

Why, though?

There it isn't.

Sees it.

I did to him.

More coffee, please.

So now we're gonna do is we're gonna wait on those code routines to run.

Now, if we run this right now, though, we're probably going to see Yeah, still runs everything synchronously.

And if we were to let's just make this one order of magnitude, okay?

Two orders of magnitude Coming right up, sir.

Area.

So it's still it's still hanging.

Right?

And they were like, What's going on, man?

So the problem is, even though this is a code routine, everything in here, though, is still synchronous like there's really no point where we actually have No I Oh, here we have no Well, okay, we have io, but not not like highlight in C i o.

We were just running this task.

So in this case, this is a book task.

This isn't really a request to a server.

What?