codingcogs' logo
دوره ی جامع FastAPI

دوره ی جامع FastAPI

3,399,000 تومان

21 فصل
مدرک اتمام دوره
پشتیبانی دائمی
FastAPI logo

FastAPI چیست؟

FastAPI یک فریم ورک توسعه ی Back-End مدرن، سریع و کم مصرف پایتونیه که مبتنی بر انواع داده های پایتون کار می کنه!

از پایتون تا برنامه نویسی وب

پایتون پرطرفدارترین زبان برنامه نویسی و پرکاربرد ترین زبان برنامه نویسی دنیاست و در کنار این مسئله اصولی به نام Zen رو رعایت میکنه که باعث میشه برنامه های پایتونی خوانا تر و بهتر از بقیه زبان های برنامه نویسی باشن. همچنین پایتون به عنوان یک زبان برنامه نویسی سطح بالا، ساده ترین روند یادگیری رو داره! پایتون یک زبان برنامه نویسی قدرتمنده و برنامه نویسی پایتون کار ساده ای نیست؛ ولی ساده میشه یادش گرفت!


حالا کنار همه ی این موارد! فرض کنید یک برنامه نویس پایتون هستید و میخواید یه برنامه ی Back-End بنویسید! آیا بهتر نبود که به جای یاد گرفتن یک زبان برنامه نویسی دیگه با خود پایتون برنامه ی بک اند رو می نوشتید؟

بله بهتر بود!


این مسئله باعث پیدایش کلی فریم ورک و کتابخونه برای زبان برنامه نویسی پایتون شد و اکثر این کتابخونه ها و فریم ورک ها به جز Djangoو Flask منسوخ شدن! Django یک فریم ورک بی نظیر بود و هست و هر روز هم از روز قبل بهتر میشه اما بیشتر مناسب پروژه های بزرگه تا کارای کوچیک و میکروسرویس ها! Flask هم با اینکه مناسب کارای کوچیک تر بود اما سرعت اصلا خوبی نداشت و نمیتونست درخواست های مختلف رو هم زمان بررسی کنه و پاسخ بده و ساختارش اجازه پیش اومدن انواع مشکلات مختلف رو میداد! پس توسعه دهنده های پایتون رسما حق نداشتن تا میکروسرویس توسعه بدن و اگر Django مناسب یک بخش پروژه نبود، پروژه با هر زبان دیگه ای به غیر از پایتون نوشته میشد!

از سیبیل تا تلسکوپ فضایی جیمز وب و Chat GPT

مشکلات بالا وجود داشت تا یه آقای مهربونی به نام سباستین رمیرز یه فریم ورک جدید نوشت!

Captains_Headshot_Resize_Sebastian-Ramirez_600x600_v1

اسم این فریم ورک رو FastAPI گذاشت و بدون هیچ چشم داشتی، شروع به توسعه ی این فریم ورک کرد! این فریم ورک روی یک پروژه ی پایتونی دیگه به اسم Starlette بنا شده بود ولی از اونجایی که Starlette یک مقداری پیچیده و سخت بود باعث شد که موفق نشه اما FastAPI سریع، قابل اطمینان و ساده بود.

الآن اما خیلی از روزهای ابتدایی FastAPI گذشته و این فریم ورک در بخش هایی از برنامه ی ارتباطی و دریافت تصویر تلسکوپ مشهور جیمز وب و ChatGPT استفاده میشه!

از Django تا FastAPI

از زمان معرفی FastAPI ، فریم ورک Django هم بیکار ننشسته و خیلی ویژگی های مهم و اساسی بهش اضافه شده اما با توجه به بزرگتر بودن هسته ی Django توسعه دهنده ها از جنگو برای بعضی از میکروسرویس ها استفاده نمی کنن و ترجیح میدن این کار رو با FastAPI انجام بدن! ضمنا از اونجایی که FastAPI در اختیار پایتون عمل میکنه و بر عکس جنگو که پایتون رو به خدمت گرفته توسعه پیدا میکنه، بهمون اجازه میده تا از هر ابزار پایتونی ای که دوست داریم استفاده کنیم تا اینکه به فکر جاگذاری اون توی قالب جنگو باشیم!

از Flask تا FastAPI

فریم ورک Flask در کمال سادگی به خاطر عدم رعایت هیچ اصولی کابوس توسعه دهنده ها بود و همچنین با اینکه از Django سبک تر بود، سرعت و عملکرد خیلی خیلی بدتری داشت! در واقع FastAPI میخ آخری بود که روی تابوت Flask کوبیده شد و تمام مشکلات Flask رو رفع کرد و کاملا جای این فریم ورک رو توی صنعت گرفت و بعد شروع کرد به گرفتن سهم NodeJS و PHP و GO.

ویژگی های FASTAPI

ویژگی های کلیدی FastAPI:

  • سرعت: سریع تر از NodeJS و Go
  • سریع تر نوشتن کد: 2 تا 3 برابر سریع تر میتوانید ویژگی های مختلف را نسبت به هر زبان و فریم ورک دیگری به برنامه ی خود اضافه کنید.
  • باگ های کمتر: احتمال خطای انسانی حدود 40% کاهش یافته است.
  • قابل درک: زمان دیباگ برنامه با سادگی استفاده و پشتیبانی کد ادیتورها به حداقل رسیده است.
  • ساده: این فریم ورک ایجاد شده که ساده، خوانا و قابل فهم باشد.
  • کوتاه: برنامه های کوتاه و ساده را به سرعت بنویسید.
  • قدرتمند: داکیومنتیشن برنامه ی شما به صورت خودکار تولید می شود! پس برنامه را بنویسید و به سرعت تست و دیپلوی کنید!

  • مبتنی بر استاندارد ها: این فریم ورک مبتنی بر استانداردهای OpenAPI و JSON Schema توسعه داده شده است.

دیگر چه چیزهایی در این دوره وجود دارد؟

دوره ی جامع FastAPI بیشتر از یک آموزش FastAPI است. در این دوره شما علاوه بر یادگیری عمیق و کاربردی FastAPI کار با دیتابیس های مختلفی را می آموزید و با مفاهیم بسیار مهم برنامه نویسی بک اند آشنا می شوید. همچنین بعضی از ابزار قدیمی تر FastAPI را با جایگزین های مدرن تر و بهتر عوض می کنیم و پس گذراندن این دوره شما به یکی از بهترین متخصصین FastAPI در دنیا تبدیل می شوید.

این دوره مناسب چه کسانی است؟

  • باید حداقل 8 گیگابایت رم داشته باشید و پردازنده شما از قابلیت مجازی سازی پشتیبانی کند!
  • باید با زبان برنامه نویسی پایتون و شی گرایی در این زبان آشنا باشید.(فصل 5 ام دوره ی کارگاه پایتون)
    همچنین بهتر است با کتابخانه های استاندارد پایتون(فصل 6) و مفاهیم Typing در زبان پایتون(فصل 14) آشنا باشید تا بتوانید سریع تر با دوره ارتباط برقرار کنید.
  • در این دوره از داکر نیز استفاده خواهیم کرد، البته نیازی به یادگیری داکر به صورت دقیق وجود ندارد اما یادگیری داکر میتواند در آینده ی حرفه ای شما تاثیر بسزایی داشته باشد.

فصل های دوره

  • 1- معرفی
  • 2- قراردادها و کلمات تخصصی
  • 3- دسترسی به پشتیبانی
  • 4- محیط جدید توسعه (آپدیت)
  • 5- Poetry(آپدیت)
  • 1- معرفی
  • 2- پیش نیاز این فصل(آپدیت Poetry)
  • 3- شروع کار با گیت
  • 4- نصب گیت
  • 5- دستورات گیت
  • 6- برنچ های گیت
  • 7- ایجاد محیط های ایزوله برای توسعه با virtualenv
  • 8- ایجاد محیط مجازی
  • 9- فعال و غیرفعال کردن محیط مجازی
  • 10- مدیریت پکیج های پایتونی با pip
  • 11- نصب pip
  • 12- کامند های پایه pip
  • 13- راه اندازی داکر
  • 14- Dockerfile
  • 15- یک اپلیکیشن ساده با FastAPI (آپدیت با Poetry)
  • 16- خلاصه این فصل
  • 1- معرفی و شروع بخش اول: Routing
  • 2- پیش نیاز این بخش (آپدیت)
  • 3- اصلا Routing در FastAPI چی هست؟
  • 4- مثالی از Routing در FastAPI
  • 5- مدیریت مسیر ها با کلاس APIRouter
  • 6- اعتبارسنجی دیتای درخواست ها با مدل های Pydantic
  • 7- مدل های تو در تو
  • 8- پارامتر های Path
  • 9- پارامتر های Query
  • 10- دیتای درخواست ها - Request Body
  • 11- Document های ساخته شده توسط FastAPI
  • 12- Swagger
  • 13- ReDoc
  • 14- ساخت یک اپلیکیشن ساده CRUD
  • 15- خلاصه این بخش
  • 16- معرفی و شروع بخش دوم: Reponse و Error Handling
  • 17- پیش نیاز این بخش(آپدیت)
  • 18- اصلا Reponse ها چی هستن؟
  • 19- Reponse Header چیه؟
  • 20- Response body چیه؟
  • 21- Status Code ها
  • 22- ساخت Response model ها
  • 23- Error handling
  • 24- خلاصه این بخش
  • 25- معرفی و شروع بخش سوم: Templating در FastAPI
  • 26- پیش نیاز این بخش (آپدیت)
  • 27- اصلا Jinja چیه؟
  • 28- فیلترها در Jinja
  • 29- استفاده از دستورات if در Jinja
  • 30- حلقه ها در Jinja
  • 31- ماکرو ها در Jinja
  • 32- استفاده از تمپلیت های Jinja در FastAPI
  • 33- خلاصه این بخش
  • 1- معرفی
  • 2- پیش نیاز این فصل
  • 3- ساختار اپلیکیشن های FastAPI
  • 4- شروع به ساخت یک اپلیکیشن planner
  • 5- پیاده سازی مدل های اپلیکیشن planner
  • 6- پیاده سازی route های اپلیکیشن planner
  • 7- پیاده سازی route های یوزر در اپلیکیشن planner
  • 8- پیاده سازی route های رویداد در اپلیکیشن planner
  • 9- خلاصه فصل
  • 1- معرفی و شروع بخش اول: مقدمات دیتابیس ها
  • 2- پیش نیاز این بخش
  • 3- شروع کار با SQLModel
  • 4- تیبل ها در SQLModel
  • 5- ردیف ها در SQLModel
  • 6- سشن ها در SQLModel
  • 7- ایجاد دیتابیس در SQLModel
  • 8- تعریف مسیر برای ایجاد رویداد ها
  • 9- تعریف مسیر برای دریافت رویداد ها
  • 10- تعریف مسیر برای آپدیت رویداد ها
  • 11- تعریف مسیر برای حذف رویداد ها
  • 12- شروع به کار با MongoDB
  • 13- داکیومنت ها در MongoDB
  • 14- شروع به استفاده از مانگو در اپلیکیشن
  • 15- متد های CRUD
  • 16- متد Create
  • 17- متد Read
  • 18- متد Update
  • 19- متد Delete
  • 20- مسیر های رویداد ها در nosql planner
  • 21- مسیر های رویداد ها در nosql planner
  • 22- خلاصه این بخش
  • 23- معرفی و شروع بخش دوم: مقدمات امنیت در اپلیکیشن های FastAPI
  • 24- پیش نیاز این بخش
  • 25- متد های authentication در FastAPI
  • 26- تزریق وابستگی / Dependency Injection
  • 27- ایجاد و استفاده کردن از یک دپندنسی
  • 28- افزایش امنیت اپلیکیشن با OAuth2 و JWT
  • 29- هش کردن پسورد ها
  • 30- ایجاد کردن و تایید کردن access token ها
  • 31- راه اندازی سیستم authentication یوزر
  • 32- آپدیت کردن مسیر لاگین یوزر
  • 33- آپدیت کردن مسیر رویداد ها
  • 34- آپدیت مسیر و مدل داکیومنت رویداد ها
  • 35- راه اندازی و تنظیم CORS
  • 36- خلاصه این بخش
  • 37- معرفی و شروع بخش سوم: تست کردن اپلیکیشن های FastAPI
  • 38- پیش نیاز این بخش
  • 39- یونیت تستینگ با pytest
  • 40- جلوگیری از تکرار کد با fixture های pytest
  • 41- راه اندازی محیط تست اپلیکیشن
  • 42- نوشتن تست برای اندپوینت های REST API
  • 43- نوشتن تست برای اندپوینت لاگین
  • 44- نوشتن تست برای اندپونت رویداد ها
  • 45- نوشتن تست برای اندپوینت های READ
  • 46- نوشتن تست برای اندپوینت CREATE
  • 47- نوشتن تست برای اندپوینت UPDATE
  • 48- نوشتن تست برای اندپوینت DELETE
  • 49- ران کردن Coverage Test
  • 50- خلاصه این بخش
  • 1- معرفی
  • 2- پیش نیاز این فصل
  • 3- ساختار بندی پروژه های بزرگتر
  • 4- پیاده سازی سرویس های API
  • 5- ایمپورت قسمت های خاص از یک ماژول
  • 6- پیاده سازی فایل اصلی اپلیکیشن - main.py
  • 7- هندل کردن exception های مربوط به API
  • 8- ریسپانس دارای یک status code
  • 9- ریسپانس دارای چندین status code
  • 10- برگردوندن خطای HTTPException
  • 11- شخصی سازی HTTPException
  • 12- جایگزین کردن یک هندلر پیش فرض از خود fastapi
  • 13- تبدیل آبجکت ها به تایپ های سازگار با JSON
  • 14- مدیریت ریسپانس های API
  • 15- ایجاد پروسه در پس زمینه
  • 16- پیاده سازی عملیات async در مسیر ها
  • 17- استفاده از middleware ها برای فیلتر کردن عملیات مسیر ها
  • 18- خلاصه این فصل
  • 1- معرفی
  • 2- پیش نیاز این فصل
  • 3- پیاده سازی IoC/DI
  • 4- اینجکت یک فانکشن دپندنسی
  • 5- اینجکت یک کلاس قابل کال شدن
  • 6- ساخت دپندنسی های تو در تو
  • 7- کش کردن دپندنسی ها
  • 8- تعریف دیتاتایپ پارامتر های Depends
  • 9- اینجکت کردن دپندنسی های async
  • 10- بررسی روش های مختلف اینجکت دپندنسی
  • 11- اینجکت دپندنسی روی سرویس ها
  • 12- اینجکت دپندنسی روی operator های path
  • 13- اینجکت دپندنسی روی router ها
  • 14- اینجکت دپندنسی روی خود فایل main.py
  • 15- قسمت بندی و مرتب سازی یک پروژه بر اساس دپندنسی های موجود
  • 16- لایه مدل
  • 17- لایه ریپازیتوری (repository)
  • 18- فکتوری متد های ریپازیتوری
  • 19- لایه سرویس
  • 20- REST API و لایه سرویس
  • 21- ساختار اصلی پروژه
  • 22- استفاده از کانتینر های خارجی یا third-party
  • 23- استفاده از کانتینر های قابل تنظیم - ابزار Dependency Injector
  • 24- استفاده از کانتینر های ساده - ابزار Lagom
  • 25- استفاده از Lagom در FastAPI
  • 26- اسکوپ قسمت هایی که به دپندنسی نیاز دارن
  • 27- خلاصه این فصل
  • 1- معرفی
  • 2- پیش نیاز این فصل
  • 3- به کارگیری الگوی decomposition
  • 4- ایجاد اپلیکیشن های زیرمجموعه اپلیکیشن اصلی / sub-applications
  • 5- مونت کردن مدل های اپلیکیشن های دیگه
  • 6- ایجاد یک gateway معمولی و رایج
  • 7- پیاده سازی اندپوینت اصلی
  • 8- ارزیابی آیدی مایکروسرویس
  • 9- به کار گیری exception handler ها
  • 10- پیاده سازی سیستم لاگینگ مرکزی
  • 11- استفاده از ماژول Loguru
  • 12- ساخت middleware برای ایجاد لاگ
  • 13- به کار گیری سرویس های REST در هم دیگه
  • 14- استفاده از ماژول httpx
  • 15- استفاده از ماژول requests
  • 16- پیاده سازی روش domain modeling
  • 17- ایجاد لایه ها
  • 18- شناسایی و تعریف domain model ها
  • 19- ساخت لایه های ریپازیتوری و سرویس
  • 20- استفاده از فکتوری متد ها در domain model ها
  • 21- مدیریت تنظیمات مایکروسرویس
  • 22- ذخیره تنظیمات به عنوان اتریبیوت های یک کلاس
  • 23- ذخیره تنظیمات در یک فایل مجزا
  • 24- خلاصه این فصل
  • 1- معرفی و شروع بخش اول: اتصال به یک دیتابیس Relational
  • 2- پیش نیاز این بخش
  • 3- آماده کردن دیتابیس برای اتصال
  • 4- اجرای عملیات CRUD روی دیتابیس با استفاده از SQLAlchemy
  • 5- نصب درایور دیتابیس
  • 6- ساخت آدرس اتصال به دیتابیس
  • 7- ساخت Session Factory
  • 8- تعریف کلاس Base
  • 9- ساخت لایه مدل ها
  • 10- پیاده سازی لایه ریپازیتوری
  • 11- اجرای عملیات بر روی دیتابیس
  • 12- ایجاد table ها
  • 14- پیاده سازی عملیات دیتابیسی async با استفاده از SQLAlchemy
  • 14- نصب درایور های دیتابیس سازگار با asyncio
  • 15- ساخت آدرس اتصال به دیتابیس (برای عملیات async)
  • 16- ساخت Session Factory (برای عملیات async)
  • 17- تعریف کلاس Base و لایه مدل ها
  • 18- ساخت لایه ریپازیتوری (برای عملیات async)
  • 19- اجرای عملیات بر روی دیتابیس به صورت async
  • 20- استفاده از GINO برای اجرای عملیات async روی دیتابیس
  • 21- نصب درایور دیتابیس: GINO
  • 22- ساخت آدرس اتصال به دیتابیس: GINO
  • 23- ساخت لایه مدل ها: GINO
  • 24- پیاده سازی عملیات دیتابیسی: GINO
  • 25- اجرای عملیات بر روی دیتابیس: GINO
  • 26- ایجاد table ها: GINO
  • 27- استفاده از Pony ORM برای لایه ریپازیتوری
  • 28- نصب درایور دیتابیس: Pony
  • 29- ساخت آدرس اتصال به دیتابیس: Pony
  • 30- تعریف کلاس های مدل ها
  • 31- پیاده سازی عملیات دیتابیسی: Pony
  • 32- اجرای عملیات بر روی دیتابیس: Pony
  • 33- ایجاد table ها: Pony
  • 34- استفاده از Peewee برای لایه ریپازیتوری
  • 35- نصب درایور دیتابیس: Peewee
  • 36- ساخت آدرس اتصال به دیتابیس: Peewee
  • 37- ایجاد table ها و لایه domain
  • 38- پیاده سازی عملیات دیتبیسی: Peewee
  • 39- اجرای عملیات بر روی دیتابیس: Peewee
  • 40- پیاده سازی الگوی CQRS
  • 41- تعریف handler interface ها
  • 42- ایجاد کلاس های کامند و کوئری
  • 43- ایجاد هندلر های کامند و کوئری
  • 44- دسترسی به هندلر ها
  • 45- خلاصه این بخش
  • 46- معرفی و شروع بخش دوم: استفاده از یک دیتابیس Non-Relational
  • 47- پیش نیاز این بخش
  • 48- آماده کردن محیط کار با دیتابیس
  • 49- به کار گیری درایور PyMongo برای کانکشن های synchronous
  • 50- ساخت آدرس اتصال به دیتابیس: PyMongo
  • 51- ساخت لایه مدل ها: PyMongo
  • 52- پیاده سازی لایه ریپازیتوری: PyMongo
  • 53- اجرای عملیات بر روی دیتابیس: PyMongo
  • 54- پیاده سازی عملیات async با استفاده از Motor
  • 55- ساخت آدرس اتصال به دیتابیس: Motor
  • 56- ساخت لایه مدل ها: Motor
  • 57- اجرای عملیات بر روی دیتابیس: Motor
  • 58- پیاده سازی عملیات async روی دیتابیس با استفاده از beanie
  • 59- ساخت آدرس اتصال به دیتابیس: beanie
  • 60- تعریف کلاس های مدل ها: beanie
  • 61- پیاده سازی عملیات CRUD دیتابیس: beanie
  • 62- اجرای عملیات بر روی دیتابیس: beanie
  • 63- ساخت لایه ریپازیتوری async: ODMantic
  • 64- ساخت آدرس اتصال به دیتابیس: ODMantic
  • 65- ساخت لایه مدل ها: ODMantic
  • 66- پیاده سازی عملیات CRUD دیتابیس: ODMantic
  • 67- اجرای عملیات بر روی دیتابیس: ODMantic
  • 68- هندل کردن عملیات CRUD دیتابیس با استفاده از MongoFrames
  • 69- ساخت آدرس اتصال به دیتابیس: MongoFrames
  • 70- ساخت لایه مدل ها: MongoFrames
  • 71- ساخت لایه ریپازیتوری: MongoFrames
  • 72- به کارگیری لایه ریپازیتوری: MongoFrames
  • 73- خلاصه این بخش
  • 1- معرفی
  • 2- پیش نیاز این فصل
  • 3- پیاده سازی اسکیم های Basic و Digest برای سیستم authentication
  • 4- استفاده از سیستم Basic authentication
  • 5- استفاده از سیستم Digest authentication
  • 6- پیاده سازی سیستم password-based authentication
  • 7- استفاده از کلاس های OAuth2PasswordBearer و OAuth2PasswordRequestForm
  • 8- پیاده سازی عملیات های دیتابیسی برای لاگین کردن یوزر
  • 9- امن کردن اندپوینت ها
  • 10- به کارگیری JWT ها
  • 11- جنریت کردن secret key
  • 12- ایجاد کردن access token
  • 13- اجرای عملیات روی دیتابیس برای لاگین کاربر
  • 14- دسترسی به اندپوینت های محافظت شده
  • 15- پیاده سازی سیستم scope-based authentication
  • 16- شخصی سازی کلاس پیش فرض OAuth2
  • 17- ساخت دیکشنری حاوی دسترسی های مختلف
  • 18- پیاده سازی عملیات لاگین کردن کاربر با OAuth2
  • 19- استفاده از اسکوپ های مورد نیاز در اندپوینت ها
  • 20- نوشتن کد authorization برای هندلر درخواست ها
  • 21- به کار گیری کلاس OAuth2AuthorizationCodeBearer
  • 22- پیاده سازی هندلر درخواست های authorization
  • 23- پیاده سازی ریسپانس های authorization
  • 24- به کار گیری پروتکل OpenID Connect
  • 25- استفاده از کلاس HTTPBearer
  • 26- نصب و راه اندازی محیط ابزار KeyCloak
  • 27- ست کردن realm و کلاینت ها در Keycloak
  • 28- ساخت یوزر و role ها
  • 29- اختصاص role به کلاینت ها
  • 30- ایجاد دسترسی های یوزر با استفاده از اسکوپ ها
  • 31- استفاده از Keycloak در FastAPI
  • 32- نوشتن کد اعتبارسنجی توکن ها
  • 33- استفاده از Auth0 با FastAPI
  • 34- استفاده از Okta در FastAPI
  • 35- استفاده از middleware های پیش فرض FastAPI برای authentication
  • 36- خلاصه این فصل
  • 1- معرفی
  • 2- پیش نیاز این فصل
  • 3- پیاده سازی coroutine ها
  • 4- به کار گیری مکانیزم coroutine switching
  • 5- نوشتن کد عملیات async
  • 6- استفاده از پروتکل HTTP/2
  • 7- ایجاد تسک های async در پس زمینه
  • 8- استفاده از coroutine ها
  • 9- ایجاد چندین تسک مختلف
  • 10- کار با تسک های celery
  • 11- ایجاد و راه اندازی یک آبجکت از celery
  • 12- ایجاد تسک در celery
  • 13- کال کردن تسک در celery
  • 14- ران کردن سرور worker
  • 15- مانیتور کردن تسک های celery
  • 16- پیاده سازی عملیات message-driven با استفاده از RabbitMQ
  • 17- ایجاد یک آبجکت از celery برای کار با RabbitMQ
  • 18- مانیتور کردن پیغام های در حال انتقال از پروتکل AMQP
  • 19- ساخت سیستم پیغام publish/subscribe با استفاده از Kafka
  • 20- اجرای بروکر و سرور Kafka
  • 21- ایجاد topic در Kafka
  • 22- نوشتن کد مربوط به قسمت publisher
  • 23- ران کردن یک consumer در کنسول
  • 24- پیاده سازی رویداد های ارسال شده توسط سرور یا Server-sent Events (SSE)
  • 25- سخت یک وب سوکت به صورت async
  • 26- پیاده سازی یک اندپوینت برای وب سوکت ساخته شده
  • 27- نوشتن کد کلاینت وب سوکت
  • 28- به کار گیری پارادایم برنامه نویسی واکنش گرا یا Reactive Programming در تسک ها
  • 29- ایجاد دیتا های قابل Observe با استفاده از coroutine ها
  • 30- ایجاد پروسه در پس زمینه
  • 31- دسترسی به اندپوینت های API
  • 32- شخصی سازی رویداد ها
  • 33- تعریف رویداد اجرایی موقع ران شدن سرور
  • 34- تعریف رویداد اجرایی موقع توقف سرور
  • 35- خلاصه این فصل
  • 1- معرفی و شروع بخش اول: ویژگی های پیشرفته دیگه از FastAPI
  • 2- پیش نیاز این بخش
  • 3- پیاده سازی سیستم مدیریت سشن ها
  • 4- ایجاد سشن یوزر ها
  • 5- مدیریت دیتای سشن ها
  • 6- پاک کردن سشن ها
  • 7- شخصی سازی BaseHTTPMiddleware
  • 8- مدیریت مکانیزم CORS
  • 9- شخصی سازی کلاس های Request و APIRoute
  • 10- مدیریت body ،form یا دیتای jSON
  • 11- Encrypt و Decrypt کردن دیتای درخواست ها
  • 12- انتخاب ریسپانس های مناسب
  • 13- شروع به استفاده از Jinja2 برای تمپلیت ها
  • 14- راه اندازی منابع static
  • 15- ایجاد قالب کلی تمپلیت
  • 16- استفاده از کلاس های ORJSONResponse و UJSONResponse
  • 17- به کار گیری استاندارد و مشخصه های OpenAPI نسخه 3
  • 18- شخصی سازی اسکیمای پیش فرض OpenAPI
  • 19- شخصی سازی اسکیما با استفاده از property های پیش فرض کد اصلی اپلیکیشن
  • 20- شخصی سازی اسکیما با استفاده از فانکشن های Query ،Form ،Body و Path
  • 21- تست کردن اندپوینت های API
  • 22- نوشتن یونیت تست ها
  • 23- شبیه سازی دپندنسی ها در تست ها
  • 24- ران کردن متد های تست
  • 25- خلاصه این بخش
  • 26- معرفی و شروع بخش دوم: مسائل پیشرفته و راه حل های مدرن
  • 27- پیش نیاز این بخش
  • 28- راه اندازی پروژه ها