Future of The Dry-Python Project

November 9, 2020
9:00 am

About

In this episode, we were joined by Nikita Sobolev, CTO at Drylabs, who talked about the future of the dry-python project. dry-python is a set of libraries for pluggable business logic components which Includes:

– returns – Make your functions return something meaningful, typed, and safe!

– classes – Smart, pythonic, ad-hoc, typed polymorphism for Python

– lambdas – Write short and fully-typed lambdas where you need them.

Transcript

hello the internet welcome to open source directions hosted by open teams

the first business to business marketplace for open source services open source directions is the webinar

that brings you all of the news about the future of your favorite open source projects

i’m melissa i’m a mathematician and software engineer based in brazil working with open source software and

communities at quansite and i’ll be your host for open source directions today co-hosting with me is

hi i’m tony fast uh i’m a developer advocate uh at kwanzai

and i’m also a community organizer outside of atlanta and i’m a huge jupiter fan

today i’m really excited uh for us to have nikita with us uh nikita could you tell us a little bit about yourself

please hi my name is nicodem i’m a city i’m a city of dry labs it is a

company based around the open source project called dry python and i also own a small company

called we make services can you guess what we do we make services so

and uh by that i mean that we do some consulting and uh some

customer development so that’s why we need a lot of tooling to do it right and today we’re going to

talk about it that’s great but before we get into the

juicy details of dry python we would like to propose a pr of the

week section so do you have any pull requests that you found particularly interesting this week

so i’ll start with mine this is a pull request that we received

at the numpy tutorials repo which is a recently created repository for educational content for numpy

and this one in particular is really exciting so it’s a deep reinforcement

learning script that trains

an agent to play pong from pixels and it’s really really cool using numpy

and you know like building everything from scratch so it’s kind of complicated the code but it it it’s really

interesting so if you want you can check it out and it’s super awesome

tony do you have that uh yeah so

i don’t contribute as much code as i would like so i watch prs like soap operas and drama

and there is this one awesome pr where somebody had built these really great markdown tools for jupiter lab and then

a good friend of mine came in and made a huge pr and the guy’s like well this is a personal project and he’s like this is

a good project so now he’s trying to uh now they’re turning it into a more official thing but it’s really cool

tooling and fun to watch the discussion happening so my pick for today it’s not really a

pull request it is just commit because i really like to force push to master because i can so

it was a really uh lovely project i started this weekend because

you know it is the perfect time to start a new project and i really enjoyed working on it i’ve

spent the whole saturday on it and it was amazing like i gets

so much like motivation from working on stuff like this it is called my pi extras uh

there are a couple of extra types you can use with my pie and this particular

commit is about making a type called utter off

it is a possibility to get an attribute of some object and get this type so it

can be a generic type it can be a fixed type so probably anything except of union types

for now because it not works sorry uh and that’s it

really cool i like those um so yeah today we are here to talk about

dry python and dry labs so dry python is a set of libraries for pluggable

business logic components it has about uh 1.4 000 stars across

repos on github so it’s more than one repo and it’s got about 9 000 downloads a

month across pipeline ypi and conda so nikita can you explain to us what is

dry labs and what have you been working on yeah sure

i will start with dry python and then i will uh discuss dry labs as well uh dry

python is a set of libraries uh and it is really important to highlight that it is a set of libraries not just a single

library and what we are trying to build is to bring some new ideas from other languages into the python itself

and how and show how these ideas can benefit a regular python developer for

now we are focused on a library called returns it is a set of primitives to

write your business logic it can really improve

things like working with exceptions because we have a special type called result uh it is a better way to

make exceptions a part of your contract so it’s not just like it can possibly

throw an exception no you are just really showing that this function is

going to throw this type of exception and you can probably highlight it everywhere you

need we also developed this new feature for python

but not new in general called high kind of types it is really impressive

that my pie allows that with little effort

so this feature allows you to express your ideas without actually showing how these ideas

should be implemented so for example you can have a function that works with some

client that goes into the http and get some page and then

probably does some stuff around it so like requests or https something like this

and you can show that you allow this function to work with both sync and sync

clients without any code changes without any type changes it will just work with

both of them because both of them returns http object http response so

that’s fine and we can work with this response later and do correct and do the correct thing with

both cases and things like this allows you to express

ideas with types as values so it can really increase the amount of

possibilities you can encode in your types and in your

business logic so that’s the first thing we are building right now it’s ready you can try it it’s not perfect but it is

working and kind of production radio i can say so

and we’re going to build some more stuff i’m going to highlight in the later sections

but for now that’s i mean library we have we also have some small

libraries called classes it is um a single dispatch with types so you’re

pretty sure what single dispatch will return to you uh we can also use

a library called lambdas numbers so uh this is something

really important in python because python has some issues with lambda functions we all know that

and our project allows you to use just an underscore and operations on

this underscore to show what do you really mean by this lambda so you can skip a lot of syntax and just

use it it is also typed it it doesn’t support all the things we want it to support but

it is better than nothing right now so

very cool um could you uh tell us a little bit about dry labs before we move

uh move along also yeah sure and uh the next question we

had about these projects is how to make them sustainable because

i work on quite a lot of projects in the open source community and i feel like

i have some limit because i can not dedicate more time on working on more projects and i have to cut my regular

work to be able to work on this project and

i like it so i decided that i should probably make this sustainable so i can

really dedicate my professional time on it not just like random time in the evenings or in the weekends and so on

and uh we don’t see any actual opportunities to do that because it’s

not sustainable to receive donations because we receive like 50 dollars a month so

you just cannot live on this money so we’ve decided to go on another

direction in another direction so we decided to build uh

high quality consulting services from um builders of the technologies to the

users of these technologies so when we say like we can

do consulting on for example drive python it means that me or some other core developer will come and show how

you can use this library how you can improve your skills about it what can

you read to understand the ideas behind it and so on uh and the same for other technologies

we offer like we have our good friends from django community

we have some other developers we are mostly focused in russian markets so we are mostly

working with the russian people right now but we are working with open teams to

increase our our coverage on international markets as

well so well that’s very cool so did uh did anybody uh as was anybody else beside

you involved in starting this um yeah and uh yeah is it filling any specific

needs uh outside of uh making sure that you get fed

yeah it is there are three people behind

dry labs initially my partner valentin dombrowski he is the

organizer of the russian python community uh called moscow python and uh

there was also a third person uh his name is arthur malashev but currently he

is on kind of sabbatical so uh currently there are two of us but

we were waiting for tom to return at some time so maybe he will maybe he will not i don’t know but uh they’re always

open so uh and um we have

several other ideas about making this whole thing possible because right now

there are several problems uh nobody address because

for now if you want to have a good consulting service you don’t know what to do because you just

cannot trust uh some people to come and give you some really important

suggestion about your architecture about your tools about your internal team and

how to structure it that’s a really important advice you can receive and you should

not just blindly follow any anyone’s advice so we need some kind of a reputation to

trust these people and what can be better reputation that building some open source tools around

it so uh i guess that’s a win-win situation for both

uh open source developers who can monetize their projects by making their

personal brand and then selling good quality consulting to clients that really need it and

they can have this multiplied effect so

they can teach for example 100 people and they can receive a lot of money for

this it is not just regular according uh coding service because you cannot receive a lot

of money for just writing code because it is limited if you want to be a 10x developer you have to teach 10

developers to be a 1x developer so that’s how it works and that’s how

uh good software engineers can make their open source work sustainable and uh i really want a lot of people to

consider this career in their future probably their current future

so that’s what we are building right now

that’s great i loved your quote about the 10-fold developer that was awesome

and can you explain a bit about the history and of the name and the logo for dry python i is the logo a shell

yeah and the shell it was originally created by artem malshev uh and uh artem decided to make this

libraries like connected together so we created uh he

created this amazing branding and you can tell by only looking

at the readme at the logo at the name of the library it is returns

lambda’s mappings [Music] classes so you can even tell by name

that it is somehow connected to dry python so we try to follow this scheme for

other projects and i guess he made a really a really great

job on that so i really enjoy our current brands and our style so

thanks a lot for building it oh the branding the branding is striking

uh it looks really great um and the typography across the repos yeah there’s a lot of care in it um so i’ve never

seen anything like these projects before are there alternative projects out here to what dry python does

uh yeah yeah there are some of them because uh we ported a lot of ideas from functional

programming into python uh obviously we are not the first ones to try it and there are a lot of awesome

libraries some of them are quite new some of them are quite old so you can

probably know libraries like funk pie

and fn dot pi uh these are popular libraries for

functional programming and i guess they’re six or maybe seven years old

but uh the main difference between our approach and their approach is uh that

they are all libraries and they were created uh before the type hints were a

thing so we leveraged the whole typing ecosystem

for our projects and you can type check them with my pie easily so

you just run my pie and you can get some some sort of proof that your

application will work and for me personally this works pretty great because

i write tests after i write tests after the actual code and firstly i just test

my code with my pi and if my pi is happy almost always my code will work

correctly so that’s my personal experience with it

i cannot say that it will be the same for other people because there are a lot of fields you can use python and you can

use different libraries you can use different tooling it might not be the same for other

users but for me that’s how it works because i use django django has state static typing and so

it works perfectly so that’s great i just want to remind the

audience that if you want to ask any questions just go to our interface um

and you can see the questions uh tab and you can input your questions we’ll answer those

at the end if we’ll have time um so yeah look at it what technology is

dry python built on i think you discussed a bit before but

we are using my pi as our core dependency it is not actually a

dependency because it’s not required in the runtime but uh there’s like a depth time dependency

there is no such thing in python so we’re just calling it a dependency but

it is not actually and tap hints because we

really use a lot of type hints in my pi some people who look at the codes inside

the dry python think that their code their end code will look the

same no that’s not true that code will be still simple and pythonic the ugly parts are

hidden inside this library and you don’t have to worry about it like just use your

beautiful decorators some beautiful functions and stuff like this we will do

the rest for you and right now when the foundation is ready i can call it ready because uh for

now we support all the things we want to support we have all the containers as we call them they’re not

really containers they’re mon ads so that’s a bit of a mystery we don’t call them

monads in public we call them containers we have all the containers we need we

have the high kind of types to allow users to write their own containers

containers and we also created this new

thing to prove that your implementation is correct it is called

monad laws as values sorry this this is how it’s called it’s not

containers it’s monotlos sorry what we do is we encode

actual laws of how things should work inside the implementation

and then you can call just one function and

our tooling will check that all these laws are correct that you will

actually have a working monad implementation or functory implementation applicative

anything you need and we do that by leveraging uh hypotheses

and property-based testing so we have interfaces like for example we

have a mappable interface which is really a functor but we call it mappable because it has the only methods called

map and it has two laws of how things should be

and every class that inherits from mappable

automatically inherits all its laws so when you write check all laws my type that

inherits from functor you will have this law checked for you you don’t need to do anything but just

write your code and it will be working so that’s the foundation we need and after

that we can create new libraries based on it for example for validation uh for

rest frameworks uh we want to build a really easy

and really reliable rest framework we have some

really cool ideas for me i i think that they’re cool other people might not might not agree with me

but i can shed some light on it for example a lot of people right now tend to use

data classes to model their rest apis and that’s a cool thing

it is really easier than to use uh for example django rest framework which has a lot of

serializers or the fields and you have to connect all the things together and it can be a little

a little too much for a simple rest framework but i wonder why not

people using dict because json is addict why do you

need a class to work with addict you can have type typed because we

already have this we already have typed and you can probably use type dig why do

you need any other class to wrap it and this can be

amazing for two for two reasons the first one is performance you

don’t need to actually create new objects you can have just dict so you receive the dict and

you work with it no extra objects created and the second idea that working with

dict is easier than working with classes because you don’t need to serialize it

and deserialize it for example if you need to save this dict you can

uh access its values and save them in some database and models or whatever but you don’t need to

serialize and deserialize that and if you need to deserialize the model for example you have some django model

and you want to convert it to a json you can use a tool like classes it will have

a function called to json and this function will single dispatch your type

and it will return return addict from it no magic uh

no performance hits because it is as simple as calling a function and returning addict

so i don’t see any problems with that and that’s the foundation we’re building

our rest framework and uh you can probably see that i haven’t

mentioned django or some other technologies here uh in the in the context of uh rest framework because

actually this rest framework can be applied to any technology you can use the same rest declaration with async io

and io http or fast fast api fast rp i’m not sure how it’s called in

english i’ve never heard how people pronounce it in english you can use the same api with django

because we have high counter types and we can encode ideas

and then just supply a different behavior that will match this type so

you can create a package with the rest api it will be

fully covered by swagger uh it will fully covered by

types and you can use it everywhere so no need to change your code no need to change your application

logic anything just use it and that’s uh

the foundation where i go into that’s not the foundation that’s uh the

next features we’re going to build with our current foundations

very cool well i’m going to be on the lookout to see if uh using container instead of monad actually makes

functional programming cool um so i’m curious uh you’re one of the maintainers pushing

these container ideas uh are there any other folks that maintain these projects yeah we also have

pablo aguilar from brazil he is our contributor and core developer he’s also

part of dry labs he does some amazing webinars for

english-speaking people we also have two other people who are

not right active right now but they were really helpful in the past and i hope they will be

working on our projects later on so dmitry and artem

really nice and i’m happy to find like a fellow brazilian and the maintainers of the project

so what communities are your users and contributors from

uh we are based in russia and our core

team is mostly russian for obvious reasons because

they’re our friends and colleagues and local people so but

right now we are trying to expand to other countries to

find some other uh users and code developers in other countries so they can

[Music] share our ideas with their colleagues and

their friends so that’s how ideas conquer the world so

well clearly the members of the dry python community are involved in the russian community uh are there any

diversity and inclusion efforts that you all participate in to uh bolster in

larger communities and enhance them yeah i try to

work on this really hard because you know there is one superstition about open source that a lot of developers

believe or think that they are not good enough to contribute to open source and this thing’s killing me because i

know a lot of great developers who are so talented and gifted but for some

reason they are not believing in themselves and uh they are scared of contributing and i work

with a lot of students and i encourage them to contribute to

open source i help them to contribute i review their pull requests before they submit them

uh i do a lot of things to encourage people to contribute because uh as open source developer i understand

that people are the most valuable asset in our work because

they literally build this stuff with their hands heads and hands so

we really need a lot of different developers to contribute to

open source and i try as hard as i can to

encourage or to enlighten people to believe in their self in in the in their selves so

they can understand that contributing to open source is not scary it is a pleasure and it is

a really warming experience that you feel like oh i did something great

and that’s the thing i try to encourage that’s really great and i’m happy to see

that your community is like healthy and moving forward in that direction

so now we’re going to move into the project demo and

we’ll get to see some of the features of dry python how it works or anything else nikita wants to discuss

so uh nikita i don’t know if you’re going to share your screen and want to share something

while you’re getting set up we would like to take this opportunity to thank our sponsor quansite for sponsoring this

episode of open source directions quansite creating value from data

so whenever you’re ready just go ahead yeah i’m ready so uh

i will cover several things in this tutorial uh we will start with

our readme because that’s what your shot should start from and we will cover uh

our main project right now it’s called returns there are several things

i want to share from this with me can you see it well is it

working it looks great and so does the branding okay

thanks uh oh we have our dogs failing sorry for that you haven’t seen

uh the first thing i want to highlight is that we have a telegram chat you can join uh if you’re interested in using or

contributing to our project if you feel like uh

you want to contribute to open source but you don’t know what to contribute to please feel free to reach me in this

chat and i will help you and the second thing i want to highlight is

the set of features we have here because that’s a really short and

really explain explanationary uh set of features we have so

uh if you will read them you will understand half of dry python for now so

uh we will just scroll down and see some more contents about it

and the first thing i want to show is our maybe container

we don’t call them on ads for a reason because people are scared of this word

for some reason functional programming looks to be hard but it’s not

and to make it easier for newcomers we

call these things different names so they won’t be scared and they will just read

through the docs we have and they will understand what you are talking about so

you can probably see this button in your codes a lot because python has none

as a value and a lot of functions can return none in some cases which probably

indicates that there is no value to return or that there is some error so

you can just return none from almost any function and if you do that you will have this uh

pattern so you have to check if some value is not none and then do your thing

it’s probably okay in some cases but in some cases it will end up in something

like this it is a ladder of if is not non if is

not non expressions so that’s not a cool thing and it can be easily changed

into this functional approach it is absolutely the same but it is

written in a flat style and it is used in our container called maybe it is pretty much the same as

optional but with extra methods like bind optional bind optional works

by executing this lambda function uh whenever the value is not known so if

the value is none it will not be called if the value is not done it is going to call this lambda function

and return the value

wrapped in the main monad again so that’s how it works and that’s

very easy to understand and that’s why it is the first example in our readme file and

the next we’re going to move to a container called requires context

and it really helps to build a scalable architecture because

uh it allows to call functions with

several parameters which are missing so for example you have this django

application you have your view and you have your business logic and you have a function called

calculatepoints it receives the strings and returns ins so you receive some word

you count letters in it that are guessed and the guest letter is something that is not dot

and later you count points for this word for example

so it’s pretty easy the problem comes when you want to

uh change for example this um

value five what you can do is you can add extra parameters to each call for

example you can have word as there and then threshold it

but you will have to do it for every function in the chain that’s not a good idea because

it will spoil your application really fast but on the other hand you can use our container called requires context it is

a reader monad from functional programming and what it does it allows to call your

functions with not all the parameters in place so we can refactor our

view and our logic to look like this for example you start with calling calculatepoints

with the word provided by user and then as a second parameter you pass your

settings so uh what happens here is that right now

your award points for letters returns not just a value but a value wrapped in

the requires context or container and it

has an extra call method uh that accepts

the values that you need to pass on the second iteration so in our example the

settings so that’s how you can decouple uh your settings from your logic and that’s how

you can decouple your logic from your

django or from your other framework of the choice so

next uh we’re moving to the result container a result container is something that

is probably the most contradictional uh in the python community because python

developers are used to rising exceptions and results

returns them instead so we can have a function that for example

makes a request to some api then it rises

exception if this request failed and then it returns

a json response from from it but inside every

call in this function can possibly rise an exception and we can understand that rights for

status probably can rise it but other functions it is not clear that they can raise

anything or it is not written anywhere so it’s hard to remember that

some functions do rise exceptions and what you can do is you can refactor your

application to actually work and look like so so

what happens here is that our make request function is

marked as safe so it will never rise any exceptions it will return them

as values and the same for our parse json

and you can convert your business logic to

this declarative approach of composing different functions so your

whole application is going to look like so flow uh the first

parameter is your data and then only functions so if you have like five steps

you can have five steps or functions and that’s fine and in the end it will return result

and here’s your successful value and here’s your

failed value so this allows you to

express what types we will will

be successful and what types will be considered as failed so you will never

forget that you have to uh that you have to work with exceptions

and that’s why it is a a great thing but for some reason python developers don’t

like it and i try to show different cases in which this technique is really useful

and it will protect your code from unexpected exceptions in different places how do you like it

wonderful i uh i wouldn’t have thought to come up with some of these solutions

uh do you know any other functional languages other than python uh no but i the one to the one tool that

i’m most experienced with is tools and desks so like functional

methods uh but using pythonic idioms

okay so uh let’s move further the next container is called io

by io we mean that this function is not pure you can clearly see that for example get

random number is not pure because a pure function is some function that will return the same uh result for the same

inputs but get random number will always return you a different number so that’s the whole

point of this function but sometimes you

have to think about what functions are pure and what functions are impure to create

a beautiful architecture and to make your application layered

because you want uh some impure stuff uh to be on

on the very very uh last layer so you can easily switch it to something else with uh marks or

composition in your tests or in your dogs something like this

uh and this one allows you to actually express

this idea so if you have something wrapped in io you will not be able to unwrap it

if you have some value marked with io it’s uh

it is forever so this allows you to stick this io marker

to your values and if you have at least one a or value it will not be possible to

say that the whole result is pure so the whole result will be impure

and this really helps you to understand the data flowing in application because

for now if you see that for example some function returns four as a result is it pure value it just

returns four or is it impure because it cures the database and shows how much users do you have for

example it’s not clear from the function itself and you cannot tell is safe to

use this function or for example it can fail that’s

really important in the big applications so we use io to mark functions that are

impure and this helps you by creating a layered architecture and it really helps you

separating pure parts of your code from impure parts of your code

and we also have your result it is something that is impure and can fail

for example all database connections all http connections are

impure and can fail so it is probably a good idea to decorate them with your

result as a container

and we also have a future container uh it is probably the same as io but for

async code the problem with async code is that you have to add extra async and the way

keywords to your business logic uh it is not really a big problem for people who is writing their applications

for example in a sync io and they just know that they will use a sync io and that’s fine but it is a big

problem for uh library authors because they don’t know how their code is going

to be used and they have to create a lot of comp com

compatibility layers to make this whole thing possible but

with our approach for example with future container you can abstract away uh

that how your ao loop works it can be synchronous with ao or it can be a

synchronous space feature so you can compose

things uh in a yo independent manner because you are going to use map

binds and other methods from functional programming and

they will hide away the exact method of composition so for example

future map will always produce a future but io map will always produce an io and for

functional programming it is not really important what types you have it can be both future or io it will have the same

properties so it is fine and

that’s probably it i’ve covered the whole readme we also have some

more information if you are interested there are at least five articles uh you can read

and we also have a great docs i believe there are a lot of examples a lot of

questions that are answered a lot of links for

other projects books tutorials everything we can find so

that was very cool um i like the uh i like to i like functional programming in python because it’s so impure and has

all the side effects um it looks like so we’ve got a few more articles that you shared some on higher kind of types and

some on the interfaces project um so we’ll share those in the chat and

i think melissa now it’s a good time to get to the road map um and see where the project’s going

yeah so can you talk to us a bit about like where is the project going recent

changes and things that you have planned for the future and i i certainly would like to note also

that your readme looks really great and you know like the examples and taking the user from one step to another that

looks awesome like what are your plans uh regarding the rest of the project where are you going and

things that you want to do with the project moving forward uh we had the big release like two weeks

ago uh it was uh this released with high kind of types and we had to break a lot

of things because um i made a lot of mistakes in

initial uh methods and initial interfaces because when you don’t have a type

checker to assist you and you you don’t have laws uh to test your implementation

you will have problems so sorry users of our previous version you will

have to change a lot of things but now these things are correct this proven that they are correct

and uh we also shipped a lot of new features

for example we shipped a very user-friendly method of working

with iterables it is called fault coming from functional programming is called foldable it is an interface

that can really assist you with working with lists for example of results

because it’s not really easy to work with a list of results the same way you can work with lists of

values because results can be failed or they can be successful

and you need some extra tooling to do that we also focused on

the sync part of our application for now it’s not perfect because i’m not a

bigger sync user so i’m not quite sure what

things we need there because i’m not using it myself and i need some advice on that

from more experienced distinct users and right now

there are some really hard tasks to do for example uh it is really problematic in i think year

to work with supervisor trees or stuff like this because if one

curtain fails you need to cancel all other keratins it’s not really easy to do that in a cinco for example

and we are based on async io so it’s really harder to do the same thing with

future uh than with viewers in kyog obviously so we need extra tooling uh for a

cincial to make this uh things easier than it is without it so that’s why

people are going to use it and uh there are a lot of things we need to

improve in the standard library because for example there are a lot of awesome

functions in python for example any uh it is really easy to carry some

iterables if any of this value is like equals to three then do this

and for now it’s not the same uh with functional

primitives because uh we also need to unwrap this value and this can be synchronous value

asynchronous failure uh dependent on the context value all other things so we need to provide

some better primitives to work with python and people can interact

with the known standard library with new values so

and we’re also going to build a new project called mappers [Music]

it is going to be like data classes but for dict because right now typedics do not

support for example default values and that’s a big problem for me because i’m

going to use typedicts a lot so we need some other abstractions and some other

tooling on that so so it sounds like the ecosystem around

dry pythons growing a little bit more you got the core internals going uh where do you see the ecosystem going and

uh yeah how do we think about that um i can say that there are three main

projects for us right now um it is called uh

mappers uh it is going to be on mappings i get mappings

sorry i don’t remember the name of my project so what can you expect from a guy looks

like me it ends with an s right yeah yeah

this is going to be this others or data classes for but for digs uh then we’re going to build a

validation library because right now all other validation libraries are not

fulfilling all the [Music] requirements we have for them for

example a lot of um validation libraries are

mixing up the schema validation and the type validation for example you have this user field

and it can be both email or user object

and at the first step you need to validate that this field is there it

doesn’t matter what type it is because you can cast these types from one to another you can query username uh you

can query a user from it’s mail and that’s okay uh but

that’s the first step at first you need to check that the schema is correct

on the second type uh on the second time you need to check that your types are correct

and then you have to check that your business rules are correct for example

you can send an integer but this integer uh represents an id in

your application and that id does not exist in a database that’s the whole new level of the

validation and you can choose how you can validate these values for

example you can combine all three layers into one response if you want to cover

everything or for example in other cases you need to check layer by layer for example you

need to check that all values are there then you need to check that all types are correct then you need to check that

all business rules are correct it really depends on your use case and for now i don’t know a single library that allows

that so that’s why we need our own and it’s going to be a valuable part of the

ecosystem and uh in our main project for now uh that will

represent uh rests framework

wow that all sounds really cool and you can see that the project is moving forward fast and you’re doing a bunch of

stuff so uh congratulations i think it’s a really nice project

um so unfortunately we’re getting close to the end of the show and uh i don’t

think we’ll have time for questions but maybe people can reach out in the repos or in the telegram group that you

mentioned before and and ask questions and maybe communicate with you

so i guess we’ll just move to our world famous sprint and rave section where we each get 15 seconds to

rent or rave about whatever topic we want nikita do you want to start

yeah i’m going to rant about my internals my pi is great i use it a lot but

every time i try to contribute some big portions of code changes to my pie i fail every time

because it is really complex it is really big and

it is really hard to understand so that’s my rant

tony uh yeah i i wanted to go back to

something nikita talked about earlier and uh you know imposter syndrome is not

something you have to deal with put yourself around people who bolster your confidence and

you know make uh make the best the next year um you’re you’re good and valuable in coding whoever you are

that’s an awesome double bed and i’ll complete so my rave is about

python brazil where uh this is our local pycon uh conference and we discussed about

all these topics that you’re mentioning like beginners how to be a community

that is beginner friendly and that values every contribution no matter the experience uh no matter where

you come from so i’m pretty happy to be a part of that and i’m raving about it

all right folks that’s all the time we have for today thanks for watching thanks for listening

you can find us on twitter at open teamsync and at quonsite ai

nikita where can people find you and drive python on github you can follow me on github or

you or you can watch some repositories you are interested in and you can join our telegram group as it was already

said so please feel free i would assume the telegram group you

have that information on your github right yeah in the readme of for each

repository so it was a good read me remember it’s in there yeah it was awesome

so if you liked what you saw today please go to our youtube channel and like and subscribe to see more of this

content we look forward to you joining us next episode for a look inside x-ray

space show thanks everybody

Resources

Company