[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8},"actionData","errors","root",{"_987":-5,"_988":419,"_989":18,"_990":991,"_992":-5,"_993":18,"_994":-5,"_995":996},"routes/products_.$courseId",{"_9":10,"_11":-5,"_12":13,"_14":15,"_16":-5,"_17":18,"_19":18,"_20":-5,"_21":22,"_23":-5,"_24":-5,"_25":26,"_27":28,"_29":-5},"course",{"_63":338,"_65":394,"_67":395,"_69":70,"_71":-5,"_72":-5,"_73":9,"_74":75,"_76":75,"_77":420,"_79":421,"_81":-5,"_82":83,"_84":422,"_86":18,"_87":-5,"_88":-5,"_89":-5,"_90":91,"_92":93,"_94":-5,"_95":-5,"_96":-5,"_97":-5,"_98":-5,"_99":-5,"_100":-5,"_101":-5,"_102":-5,"_103":-5,"_104":-5,"_105":-5,"_106":-5,"_107":-5,"_108":-5,"_109":-5,"_110":423,"_424":425},"student","completedLessonIds",[],"enrolledCourseIds",[],"isAdmin","isEnrolled",false,"isPaused","overdueInvoiceUrl","tenant",{"_63":83,"_114":419},"announcement","currentVideoTokenData","stripeAccountId","acct_1TJh51G6VvyH95Ot","allCourses",[30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62],"resolvedCoupon",{"_63":410,"_65":411,"_67":412,"_69":70,"_71":-5,"_72":-5,"_73":9,"_74":75,"_76":75,"_77":413,"_79":414,"_81":-5,"_82":83,"_84":415,"_86":18,"_87":-5,"_88":-5,"_89":-5,"_90":91,"_92":93,"_94":-5,"_95":-5,"_96":-5,"_97":-5,"_98":-5,"_99":-5,"_100":-5,"_101":-5,"_102":-5,"_103":-5,"_104":-5,"_105":-5,"_106":-5,"_107":-5,"_108":-5,"_109":-5,"_110":416},{"_63":337,"_65":402,"_67":403,"_69":70,"_71":-5,"_72":-5,"_73":9,"_74":75,"_76":75,"_77":404,"_79":405,"_81":-5,"_82":83,"_84":406,"_86":18,"_87":-5,"_88":-5,"_89":-5,"_90":91,"_92":93,"_94":-5,"_95":-5,"_96":-5,"_97":-5,"_98":-5,"_99":-5,"_100":-5,"_101":-5,"_102":-5,"_103":-5,"_104":-5,"_105":-5,"_106":-5,"_107":-5,"_108":-5,"_109":-5,"_110":407},{"_63":338,"_65":394,"_67":395,"_69":70,"_71":-5,"_72":-5,"_73":9,"_74":75,"_76":75,"_77":396,"_79":397,"_81":-5,"_82":83,"_84":398,"_86":18,"_87":-5,"_88":-5,"_89":-5,"_90":91,"_92":93,"_94":-5,"_95":-5,"_96":-5,"_97":-5,"_98":-5,"_99":-5,"_100":-5,"_101":-5,"_102":-5,"_103":-5,"_104":-5,"_105":-5,"_106":-5,"_107":-5,"_108":-5,"_109":-5,"_110":399},{"_63":336,"_65":386,"_67":387,"_69":70,"_71":-5,"_72":-5,"_73":9,"_74":75,"_76":75,"_77":388,"_79":389,"_81":-5,"_82":83,"_84":390,"_86":18,"_87":-5,"_88":-5,"_89":-5,"_90":91,"_92":93,"_94":-5,"_95":-5,"_96":-5,"_97":-5,"_98":-5,"_99":-5,"_100":-5,"_101":-5,"_102":-5,"_103":-5,"_104":-5,"_105":-5,"_106":-5,"_107":-5,"_108":-5,"_109":-5,"_110":391},{"_63":377,"_65":378,"_67":379,"_69":70,"_71":-5,"_72":-5,"_73":9,"_74":75,"_76":75,"_77":380,"_79":381,"_81":-5,"_82":83,"_84":382,"_86":18,"_87":-5,"_88":-5,"_89":-5,"_90":91,"_92":93,"_94":-5,"_95":-5,"_96":-5,"_97":-5,"_98":-5,"_99":-5,"_100":-5,"_101":-5,"_102":-5,"_103":-5,"_104":-5,"_105":-5,"_106":-5,"_107":-5,"_108":-5,"_109":-5,"_110":383},{"_63":339,"_65":369,"_67":370,"_69":70,"_71":-5,"_72":-5,"_73":9,"_74":75,"_76":75,"_77":371,"_79":372,"_81":-5,"_82":83,"_84":373,"_86":18,"_87":-5,"_88":-5,"_89":-5,"_90":91,"_92":93,"_94":-5,"_95":-5,"_96":-5,"_97":-5,"_98":-5,"_99":-5,"_100":-5,"_101":-5,"_102":-5,"_103":-5,"_104":-5,"_105":-5,"_106":-5,"_107":-5,"_108":-5,"_109":-5,"_110":374},{"_63":360,"_65":361,"_67":362,"_69":70,"_71":-5,"_72":-5,"_73":9,"_74":75,"_76":75,"_77":363,"_79":364,"_81":-5,"_82":83,"_84":365,"_86":18,"_87":-5,"_88":-5,"_89":-5,"_90":91,"_92":93,"_94":-5,"_95":-5,"_96":-5,"_97":-5,"_98":-5,"_99":-5,"_100":-5,"_101":-5,"_102":-5,"_103":-5,"_104":-5,"_105":-5,"_106":-5,"_107":-5,"_108":-5,"_109":-5,"_110":366},{"_63":350,"_65":351,"_67":352,"_69":70,"_71":-5,"_72":-5,"_73":9,"_74":75,"_76":75,"_77":353,"_79":354,"_81":-5,"_82":83,"_84":355,"_86":18,"_87":-5,"_88":-5,"_89":-5,"_90":91,"_92":93,"_94":-5,"_95":-5,"_96":-5,"_97":-5,"_98":-5,"_99":-5,"_100":-5,"_101":-5,"_102":-5,"_103":-5,"_104":-5,"_105":-5,"_106":-5,"_107":-5,"_108":-5,"_109":-5,"_110":356},{"_63":340,"_65":341,"_67":342,"_69":70,"_71":-5,"_72":-5,"_73":9,"_74":75,"_76":75,"_77":343,"_79":344,"_81":-5,"_82":83,"_84":345,"_86":18,"_87":-5,"_88":-5,"_89":-5,"_90":91,"_92":93,"_94":-5,"_95":-5,"_96":-5,"_97":-5,"_98":-5,"_99":-5,"_100":-5,"_101":-5,"_102":-5,"_103":-5,"_104":-5,"_105":-5,"_106":-5,"_107":-5,"_108":-5,"_109":-5,"_110":346},{"_63":324,"_65":325,"_67":326,"_69":70,"_71":-5,"_72":-5,"_73":327,"_74":75,"_76":75,"_77":328,"_79":329,"_81":-5,"_82":83,"_84":330,"_86":18,"_87":-5,"_88":-5,"_89":-5,"_90":91,"_92":93,"_94":-5,"_95":-5,"_96":-5,"_97":-5,"_98":-5,"_99":-5,"_100":-5,"_101":-5,"_102":-5,"_103":-5,"_104":-5,"_105":-5,"_106":-5,"_107":-5,"_108":-5,"_109":-5,"_110":331},{"_63":314,"_65":315,"_67":68,"_69":70,"_71":-5,"_72":-5,"_73":9,"_74":75,"_76":75,"_77":316,"_79":317,"_81":-5,"_82":83,"_84":318,"_86":18,"_87":-5,"_88":-5,"_89":-5,"_90":91,"_92":93,"_94":-5,"_95":-5,"_96":-5,"_97":-5,"_98":-5,"_99":-5,"_100":-5,"_101":-5,"_102":-5,"_103":-5,"_104":-5,"_105":-5,"_106":-5,"_107":-5,"_108":-5,"_109":-5,"_110":319},{"_63":306,"_65":307,"_67":68,"_69":70,"_71":-5,"_72":-5,"_73":9,"_74":75,"_76":18,"_77":308,"_79":309,"_81":-5,"_82":83,"_84":310,"_86":18,"_87":-5,"_88":-5,"_89":-5,"_90":91,"_92":93,"_94":-5,"_95":-5,"_96":-5,"_97":-5,"_98":-5,"_99":-5,"_100":-5,"_101":-5,"_102":-5,"_103":-5,"_104":-5,"_105":-5,"_106":-5,"_107":-5,"_108":-5,"_109":-5,"_110":311},{"_63":297,"_65":298,"_67":299,"_69":70,"_71":-5,"_72":-5,"_73":9,"_74":75,"_76":75,"_77":300,"_79":301,"_81":-5,"_82":83,"_84":302,"_86":18,"_87":-5,"_88":-5,"_89":-5,"_90":91,"_92":93,"_94":-5,"_95":-5,"_96":-5,"_97":-5,"_98":-5,"_99":-5,"_100":-5,"_101":-5,"_102":-5,"_103":-5,"_104":-5,"_105":-5,"_106":-5,"_107":-5,"_108":-5,"_109":-5,"_110":303},{"_63":287,"_65":288,"_67":289,"_69":70,"_71":-5,"_72":-5,"_73":9,"_74":75,"_76":75,"_77":290,"_79":291,"_81":-5,"_82":83,"_84":292,"_86":18,"_87":-5,"_88":-5,"_89":-5,"_90":91,"_92":93,"_94":-5,"_95":-5,"_96":-5,"_97":-5,"_98":-5,"_99":-5,"_100":-5,"_101":-5,"_102":-5,"_103":-5,"_104":-5,"_105":-5,"_106":-5,"_107":-5,"_108":-5,"_109":-5,"_110":293},{"_63":274,"_65":275,"_67":276,"_69":277,"_71":278,"_72":279,"_73":9,"_74":75,"_76":75,"_77":280,"_79":281,"_81":-5,"_82":83,"_84":282,"_86":18,"_87":-5,"_88":-5,"_89":-5,"_90":91,"_92":93,"_94":-5,"_95":-5,"_96":-5,"_97":-5,"_98":-5,"_99":-5,"_100":-5,"_101":-5,"_102":-5,"_103":-5,"_104":-5,"_105":-5,"_106":-5,"_107":-5,"_108":-5,"_109":-5,"_110":283},{"_63":265,"_65":266,"_67":267,"_69":70,"_71":-5,"_72":-5,"_73":9,"_74":75,"_76":75,"_77":268,"_79":269,"_81":-5,"_82":83,"_84":270,"_86":18,"_87":-5,"_88":-5,"_89":-5,"_90":91,"_92":93,"_94":-5,"_95":-5,"_96":-5,"_97":-5,"_98":-5,"_99":-5,"_100":-5,"_101":-5,"_102":-5,"_103":-5,"_104":-5,"_105":-5,"_106":-5,"_107":-5,"_108":-5,"_109":-5,"_110":271},{"_63":256,"_65":257,"_67":68,"_69":70,"_71":-5,"_72":-5,"_73":9,"_74":75,"_76":75,"_77":258,"_79":259,"_81":-5,"_82":83,"_84":260,"_86":18,"_87":-5,"_88":-5,"_89":-5,"_90":91,"_92":93,"_94":-5,"_95":-5,"_96":-5,"_97":-5,"_98":-5,"_99":-5,"_100":-5,"_101":-5,"_102":-5,"_103":-5,"_104":-5,"_105":-5,"_106":-5,"_107":-5,"_108":-5,"_109":-5,"_110":261},{"_63":248,"_65":249,"_67":68,"_69":70,"_71":-5,"_72":-5,"_73":9,"_74":75,"_76":75,"_77":250,"_79":251,"_81":-5,"_82":83,"_84":252,"_86":18,"_87":-5,"_88":-5,"_89":-5,"_90":91,"_92":93,"_94":-5,"_95":-5,"_96":-5,"_97":-5,"_98":-5,"_99":-5,"_100":-5,"_101":-5,"_102":-5,"_103":-5,"_104":-5,"_105":-5,"_106":-5,"_107":-5,"_108":-5,"_109":-5,"_110":253},{"_63":239,"_65":240,"_67":68,"_69":70,"_71":-5,"_72":-5,"_73":9,"_74":75,"_76":75,"_77":241,"_79":242,"_81":-5,"_82":83,"_84":243,"_86":18,"_87":-5,"_88":-5,"_89":-5,"_90":91,"_92":93,"_94":-5,"_95":-5,"_96":-5,"_97":-5,"_98":-5,"_99":-5,"_100":-5,"_101":-5,"_102":-5,"_103":-5,"_104":-5,"_105":-5,"_106":-5,"_107":-5,"_108":-5,"_109":-5,"_110":244},{"_63":230,"_65":231,"_67":68,"_69":70,"_71":-5,"_72":-5,"_73":232,"_74":18,"_76":18,"_77":233,"_79":234,"_81":-5,"_82":83,"_84":235,"_86":18,"_87":-5,"_88":-5,"_89":-5,"_90":91,"_92":93,"_94":-5,"_95":-5,"_96":-5,"_97":-5,"_98":-5,"_99":-5,"_100":-5,"_101":-5,"_102":-5,"_103":-5,"_104":-5,"_105":-5,"_106":-5,"_107":-5,"_108":-5,"_109":-5,"_110":236},{"_63":220,"_65":221,"_67":222,"_69":70,"_71":-5,"_72":-5,"_73":131,"_74":75,"_76":75,"_77":223,"_79":224,"_81":-5,"_82":83,"_84":225,"_86":18,"_87":-5,"_88":-5,"_89":-5,"_90":91,"_92":93,"_94":-5,"_95":-5,"_96":-5,"_97":-5,"_98":-5,"_99":-5,"_100":-5,"_101":-5,"_102":-5,"_103":-5,"_104":-5,"_105":-5,"_106":-5,"_107":-5,"_108":-5,"_109":226,"_110":227},{"_63":210,"_65":211,"_67":212,"_69":70,"_71":-5,"_72":-5,"_73":131,"_74":75,"_76":75,"_77":213,"_79":214,"_81":-5,"_82":83,"_84":215,"_86":18,"_87":-5,"_88":-5,"_89":-5,"_90":91,"_92":93,"_94":-5,"_95":-5,"_96":-5,"_97":-5,"_98":-5,"_99":-5,"_100":-5,"_101":-5,"_102":-5,"_103":-5,"_104":-5,"_105":-5,"_106":-5,"_107":-5,"_108":-5,"_109":216,"_110":217},{"_63":200,"_65":201,"_67":202,"_69":70,"_71":-5,"_72":-5,"_73":131,"_74":75,"_76":75,"_77":203,"_79":204,"_81":-5,"_82":83,"_84":205,"_86":18,"_87":-5,"_88":-5,"_89":-5,"_90":91,"_92":93,"_94":-5,"_95":-5,"_96":-5,"_97":-5,"_98":-5,"_99":-5,"_100":-5,"_101":-5,"_102":-5,"_103":-5,"_104":-5,"_105":-5,"_106":-5,"_107":-5,"_108":-5,"_109":206,"_110":207},{"_63":191,"_65":192,"_67":193,"_69":70,"_71":-5,"_72":-5,"_73":9,"_74":75,"_76":75,"_77":194,"_79":195,"_81":-5,"_82":83,"_84":196,"_86":18,"_87":-5,"_88":-5,"_89":-5,"_90":91,"_92":93,"_94":-5,"_95":-5,"_96":-5,"_97":-5,"_98":-5,"_99":-5,"_100":-5,"_101":-5,"_102":-5,"_103":-5,"_104":-5,"_105":-5,"_106":-5,"_107":-5,"_108":-5,"_109":-5,"_110":197},{"_63":182,"_65":183,"_67":184,"_69":70,"_71":-5,"_72":-5,"_73":9,"_74":75,"_76":75,"_77":185,"_79":186,"_81":-5,"_82":83,"_84":187,"_86":18,"_87":-5,"_88":-5,"_89":-5,"_90":91,"_92":93,"_94":-5,"_95":-5,"_96":-5,"_97":-5,"_98":-5,"_99":-5,"_100":-5,"_101":-5,"_102":-5,"_103":-5,"_104":-5,"_105":-5,"_106":-5,"_107":-5,"_108":-5,"_109":-5,"_110":188},{"_63":173,"_65":174,"_67":175,"_69":70,"_71":-5,"_72":-5,"_73":131,"_74":75,"_76":18,"_77":176,"_79":177,"_81":-5,"_82":83,"_84":178,"_86":18,"_87":-5,"_88":-5,"_89":-5,"_90":91,"_92":93,"_94":-5,"_95":-5,"_96":-5,"_97":-5,"_98":-5,"_99":-5,"_100":-5,"_101":-5,"_102":-5,"_103":-5,"_104":-5,"_105":-5,"_106":-5,"_107":-5,"_108":-5,"_109":-5,"_110":179},{"_63":165,"_65":166,"_67":68,"_69":70,"_71":-5,"_72":-5,"_73":9,"_74":75,"_76":75,"_77":167,"_79":168,"_81":-5,"_82":83,"_84":169,"_86":18,"_87":-5,"_88":-5,"_89":-5,"_90":91,"_92":93,"_94":-5,"_95":-5,"_96":-5,"_97":-5,"_98":-5,"_99":-5,"_100":-5,"_101":-5,"_102":-5,"_103":-5,"_104":-5,"_105":-5,"_106":-5,"_107":-5,"_108":-5,"_109":-5,"_110":170},{"_63":157,"_65":158,"_67":68,"_69":70,"_71":-5,"_72":-5,"_73":9,"_74":75,"_76":18,"_77":159,"_79":160,"_81":-5,"_82":83,"_84":161,"_86":18,"_87":-5,"_88":-5,"_89":-5,"_90":91,"_92":93,"_94":-5,"_95":-5,"_96":-5,"_97":-5,"_98":-5,"_99":-5,"_100":-5,"_101":-5,"_102":-5,"_103":-5,"_104":-5,"_105":-5,"_106":-5,"_107":-5,"_108":-5,"_109":-5,"_110":162},{"_63":149,"_65":150,"_67":68,"_69":70,"_71":-5,"_72":-5,"_73":9,"_74":75,"_76":18,"_77":151,"_79":152,"_81":-5,"_82":83,"_84":153,"_86":18,"_87":-5,"_88":-5,"_89":-5,"_90":91,"_92":93,"_94":-5,"_95":-5,"_96":-5,"_97":-5,"_98":-5,"_99":-5,"_100":-5,"_101":-5,"_102":-5,"_103":-5,"_104":-5,"_105":-5,"_106":-5,"_107":-5,"_108":-5,"_109":-5,"_110":154},{"_63":139,"_65":140,"_67":141,"_69":70,"_71":-5,"_72":-5,"_73":9,"_74":75,"_76":75,"_77":142,"_79":143,"_81":-5,"_82":83,"_84":144,"_86":18,"_87":-5,"_88":-5,"_89":-5,"_90":91,"_92":93,"_94":-5,"_95":-5,"_96":-5,"_97":-5,"_98":-5,"_99":-5,"_100":-5,"_101":-5,"_102":-5,"_103":-5,"_104":-5,"_105":-5,"_106":-5,"_107":-5,"_108":-5,"_109":-5,"_110":145},{"_63":128,"_65":129,"_67":130,"_69":70,"_71":-5,"_72":-5,"_73":131,"_74":75,"_76":75,"_77":132,"_79":133,"_81":-5,"_82":83,"_84":134,"_86":18,"_87":-5,"_88":-5,"_89":-5,"_90":91,"_92":93,"_94":-5,"_95":-5,"_96":-5,"_97":-5,"_98":-5,"_99":-5,"_100":-5,"_101":-5,"_102":-5,"_103":-5,"_104":-5,"_105":-5,"_106":-5,"_107":-5,"_108":-5,"_109":135,"_110":136},{"_63":119,"_65":120,"_67":68,"_69":70,"_71":-5,"_72":-5,"_73":9,"_74":75,"_76":18,"_77":121,"_79":122,"_81":-5,"_82":83,"_84":123,"_86":18,"_87":-5,"_88":-5,"_89":-5,"_90":91,"_92":93,"_94":-5,"_95":-5,"_96":-5,"_97":-5,"_98":-5,"_99":-5,"_100":-5,"_101":-5,"_102":-5,"_103":-5,"_104":-5,"_105":-5,"_106":-5,"_107":-5,"_108":-5,"_109":-5,"_110":124},{"_63":64,"_65":66,"_67":68,"_69":70,"_71":-5,"_72":-5,"_73":9,"_74":75,"_76":75,"_77":78,"_79":80,"_81":-5,"_82":83,"_84":85,"_86":18,"_87":-5,"_88":-5,"_89":-5,"_90":91,"_92":93,"_94":-5,"_95":-5,"_96":-5,"_97":-5,"_98":-5,"_99":-5,"_100":-5,"_101":-5,"_102":-5,"_103":-5,"_104":-5,"_105":-5,"_106":-5,"_107":-5,"_108":-5,"_109":-5,"_110":111},"id","dbebab49-e694","title","Plan Smoke 2026-07-27","description","","duration","0h","level","instructor","type","upgradesEnabled",true,"published","createdAt",["D",1785167498249],"updatedAt",["D",1785167498249],"deletedAt","tenantId","d135c4b1-642c-4493-a965-4eaeb1565727","includedProductIds",[],"showCheckoutButton","checkoutLessonId","checkoutProductId","checkoutButtonText","checkoutPosition","below","checkoutAlignment","center","salesCardBadge","salesCardHeadline","salesCardSubheadline","salesCardFeatures","salesCardGuarantees","salesCardStyle","salesCardProductId","salesCardDiscountType","salesCardDiscountValue","salesCardCouponCode","salesCardCouponId","checkoutButtonStyle","salesCardPrice","salesCardOriginalPrice","salesCardDiscount","destinationUrl","pricingTiers",[112],{"_63":113,"_114":115,"_116":117,"_67":68,"_118":64,"_82":83},"4e8fc029-cb27-4ef9-bfbd-3c8c0c3bcaba","name","Tier 1","priceInCents",400,"courseId","9a16b44d-8c74","Free 5 Day Course - SaaS in the Age of AI",["D",1784127194621],["D",1785160802763],[],[125],{"_63":126,"_114":115,"_116":127,"_67":68,"_118":119,"_82":83},"10e7dfe3-7039-4752-927c-fddde2179bff",0,"b7e74ce6-9664","Backend Engineering Mindmap","Free backend engineering mindmap: see how all the core concepts connect.","link",["D",1783230664160],["D",1785091439785],[],"https://coggle.it/diagram/ZtMDf8rvLIwlbc-0/t/backend-engineering/44ac2c05e0c7fcdd9920723c49ec128e5a65bcc430a145638eb01f5c64a884a1",[137],{"_63":138,"_114":115,"_116":127,"_67":68,"_118":128,"_82":83},"6f10eac8-7fdb-4e64-a764-34b49be17e33","0fbad6e2-38a8","Agentic AI Level 1","The full operator curriculum: spec-first planning, MCP and real account access, skills, subagents, hooks, and verification. Includes API and MCP sandbox access and the private community.",["D",1783438401230],["D",1784602154619],[],[146],{"_63":147,"_114":115,"_116":148,"_67":68,"_118":139,"_82":83},"bb289047-c2a7-4ac9-8511-1f36e97d2cbd",999900,"b27b9579-a681","Sample Product",["D",1783738854333],["D",1783910984133],[],[155],{"_63":156,"_114":115,"_116":148,"_67":68,"_118":149,"_82":83},"f0dc0292-c125-40ca-a815-5ef2d0e31fe1","acce3719-cbea","Software Engineering Mentorship",["D",1783880492922],["D",1783880492922],[],[163],{"_63":164,"_114":115,"_116":127,"_67":68,"_118":157,"_82":83},"85d21391-b99b-4f6e-98a7-7cde58fc63e0","63765398-fb1e","YouTube Notes",["D",1784006163013],["D",1784387179777],[],[171],{"_63":172,"_114":115,"_116":127,"_67":68,"_118":165,"_82":83},"4e7b2772-5ba9-47c3-a43c-dc53e43efd36","d5462615-9451","Backend Python Notes","Free Backend Python notes: a practical reference for building backend web applications with Python and Django.",["D",1784351164015],["D",1784352177158],[],[180],{"_63":181,"_114":115,"_116":127,"_67":68,"_118":173,"_82":83},"4aa75988-ad85-4d39-bd2e-139a20037bbf","87e81fc9-8709","Agentic AI Level 2","Everything in Level 1, plus a practical skill library (Excalidraw, listener agents, publish pipelines), deterministic builds with pure functions and testing, dockerized dangerous mode, a micro-SaaS capstone with code reviews, and 3 months of Course Catalyst free. Includes Agentic AI Level 1.",["D",1783438412167],["D",1783452488097],[139],[189],{"_63":190,"_114":115,"_116":148,"_67":68,"_118":182,"_82":83},"a4c65066-31e4-4f5a-8f42-dbfd6b7fa971","e1973a8b-53cb","Agentic AI Level 3","Agentic Business Mentorship — personalized 1:1 mentoring to put AI to work in your business. Done-with-you agentic workflows, skills, and subagents. support building AI features. the playbooks used to run a real SaaS. Max 5 seats. Includes Agentic AI Level 1 and Level 2.",["D",1783438421524],["D",1783452488611],[139,182],[198],{"_63":199,"_114":115,"_116":148,"_67":68,"_118":191,"_82":83},"a97cc7bb-3864-40e3-984d-e4b456c3e12f","4957ee48-4868","REST API Notes","Free REST API notes — a practical reference for designing and consuming REST APIs.",["D",1783230665977],["D",1783258213814],[],"https://docs.google.com/document/d/1v0l4TC2ZyFYyk6Y0ggFw86li2F6cwr5GLuTUyrzSpT4/edit?usp=sharing",[208],{"_63":209,"_114":115,"_116":127,"_67":68,"_118":200,"_82":83},"998464d9-c4f3-484b-8bd2-13d8470d2442","ce008ede-884d","Notion Video Notes","Free Notion video notes — organized notes for the video series.",["D",1783230665073],["D",1783258213280],[],"https://calcur.tech/notes-direct",[218],{"_63":219,"_114":115,"_116":127,"_67":68,"_118":210,"_82":83},"a9871ccd-3ec3-4537-922c-752d0ead71df","9d8ada3b-4f5a","C Programming Notes","Free C programming notes — everything you need to reference the C language.",["D",1783230663246],["D",1783258209577],[],"https://docs.google.com/document/d/1kDGgpIFlDwkQ9a-3id8dAvuz9X5a57GPelyTXOppIcA/edit?usp=sharing",[228],{"_63":229,"_114":115,"_116":127,"_67":68,"_118":220,"_82":83},"6dd65d4c-a76c-415a-b07b-c30643a5b161","a12f794f-9534","test download","download",["D",1783231936251],["D",1783231942221],[],[237],{"_63":238,"_114":115,"_116":127,"_67":68,"_118":230,"_82":83},"b41721b4-011d-408a-9d80-38c65e90ff42","7cfb18e8-e3a3","Beginner Software Engineering Fundamentals",["D",1783210845154],["D",1783635789075],[],[245],{"_63":246,"_114":115,"_116":247,"_67":68,"_118":239,"_82":83},"3007b27a-112d-4767-8f51-d652abfc221d",9700,"8bea329b-9512","Fundamentals Free Preview",["D",1783210844913],["D",1783217254804],[],[254],{"_63":255,"_114":115,"_116":127,"_67":68,"_118":248,"_82":83},"035ef5b8-8757-414f-afe6-4ed4a01ef0a6","b29b3b07-6e65","Intermediate Fundamentals",["D",1783210845451],["D",1783212251014],[239],[262],{"_63":263,"_114":115,"_116":264,"_67":68,"_118":256,"_82":83},"2166b8fb-e071-4c64-b3b1-191771664efa",29700,"fdec9ccb-6d5f-4adb-b935-bd296398baff","LeetCode 100","Work in progress",["D",1776094802038],["D",1782345570360],[],[272],{"_63":273,"_114":115,"_116":148,"_67":68,"_118":265,"_82":83},"0ac426c1-b6a7-448d-a9de-dc92d23e9384","2e665b82-16d4-4ccd-9a6a-d76254817060","Backend Software Engineering","Master Applied Backend Engineering","6 hours","Advanced","Sarah Drasner",["D",1766190302360],["D",1782345648504],[],[284],{"_63":285,"_114":115,"_116":286,"_67":68,"_118":274,"_82":83},"46ebe981-1fb1-4c3e-ac18-ab6d427fb352",59700,"a14d1966-5bf8-48bb-b137-f52ec60adf1f","Old School Python Mastery","The OG Python Mastery course",["D",1776094557239],["D",1779982275149],[],[294],{"_63":295,"_114":115,"_116":296,"_67":68,"_118":287,"_82":83},"cafbdc86-4f26-432d-b22d-cc990042cfbc",39700,"f4b5c609-a9fd-4982-915c-275b9bff2883","Free React Course","Everything you need to build with React",["D",1776094681052],["D",1779930409564],[],[304],{"_63":305,"_114":115,"_116":127,"_67":68,"_118":297,"_82":83},"f175fd81-59f9-4510-af86-312743c68cf9","178294a1-04bf","Core Curriculum",["D",1779983145523],["D",1779983162351],[],[312],{"_63":313,"_114":115,"_116":127,"_67":68,"_118":306,"_82":83},"e4cbe0e5-cbc7-40ff-a612-26fbdaa55181","fe8eede0-1ee9-4242-be69-be8213acf5a2","Advanced Software Engineering Fundamentals",["D",1774171624976],["D",1783635802164],[239,256],[320],{"_63":321,"_114":322,"_116":323,"_67":68,"_118":314,"_82":83},"56bd5480-0fb2-44e8-9259-4b42a143d21a","Free Preview",49700,"8fd64db1-954d","Software Engineering Mastery","The complete end-to-end program: every CodeBreakthrough course in one bundle.","bundle",["D",1783129694848],["D",1783129694848],[314,274,336,265,337,338,339],[332],{"_63":333,"_114":334,"_116":335,"_67":68,"_118":324,"_82":83},"ac3d5f53-195e-438a-abf4-6c85af955442","Complete Bundle",199700,"bd921a4e-c838-474e-b2ca-cde010bc48e1","347905ee-84bd-422a-897d-b79eea8a0370","996a4299-1f0b-465e-a972-e25ce2c63681","03e8b844-9be6-4ffe-8d18-18f660a3dfc1","0b60de48-006d-439b-a14d-ec024c410fed","CodeBreakthrough Vault","All my career training and live calls",["D",1775757076510],["D",1777044357238],[],[347],{"_63":348,"_114":115,"_116":349,"_67":68,"_118":340,"_82":83},"85cd5a43-25f3-484d-b778-8da98ad94b8a",99999,"a013d98a-3caf-4321-8357-c445e06cdaf7","Backend Python","Learn how to use Python for backend web development",["D",1776094587585],["D",1777044063843],[],[357],{"_63":358,"_114":115,"_116":359,"_67":68,"_118":350,"_82":83},"9b4a4064-fca5-409f-8c55-5be946ce4cc2",19700,"f96ca125-33c0-4f81-8efa-c6d4a029027f","Ultimate Programming All-in-One Tutorials","Get all of my All-in-One tutorials for free!",["D",1775336455703],["D",1775337275440],[],[367],{"_63":368,"_114":115,"_116":127,"_67":68,"_118":360,"_82":83},"ef57445c-d1ba-4efc-9553-f8e9eb15719b","C and C++ Mastery","Everything you need to master C and C++",["D",1776094621823],["D",1777044037226],[],[375],{"_63":376,"_114":115,"_116":323,"_67":68,"_118":339,"_82":83},"d73e221d-6f40-4cd6-8e5a-ae90961c2f88","e6ea1713-0b8c-4e3b-891f-8cc651fa917d","C Programming Crash Course","Get started with C programming",["D",1776094740551],["D",1777044004126],[],[384],{"_63":385,"_114":115,"_116":127,"_67":68,"_118":377,"_82":83},"828b182e-5441-4ef3-9e3f-7d30fef67735","Data Structures and Algorithms","Everything you need to master DSA",["D",1775050959587],["D",1777044472464],[],[392],{"_63":393,"_114":115,"_116":296,"_67":68,"_118":336,"_82":83},"b39ecc93-9499-4166-b800-43a99ef2f0c7","Python Mastery","Everything you need to Master Python",["D",1773929154561],["D",1777044409436],[],[400],{"_63":401,"_114":115,"_116":296,"_67":68,"_118":338,"_82":83},"4a2b57c5-ef3c-419c-b824-5e8c79777f92","AI Mastery","Everything you need to master AI as a Software Engineer",["D",1776094784395],["D",1777043977192],[],[408],{"_63":409,"_114":115,"_116":296,"_67":68,"_118":337,"_82":83},"72d94d89-be8f-4a3e-89e6-7b85a736b3ca","dfef7f70-a343-4473-9f05-9553447245c0","Computer Science Mastery","Everything you need to Master Computer Science",["D",1777043099984],["D",1777043478682],[],[417],{"_63":418,"_114":115,"_116":127,"_67":68,"_118":410,"_82":83},"83196136-62cc-47dc-ae40-0101fb71d08d","CodeBreakthrough",["D",1773929154561],["D",1777044409436],[],[986],"sections",[426,427,428,429,430,431,432,433,434,435,436],{"_63":977,"_65":978,"_67":68,"_439":127,"_441":18,"_118":338,"_82":83,"_442":979},{"_63":888,"_65":889,"_67":68,"_439":490,"_441":18,"_118":338,"_82":83,"_442":890},{"_63":808,"_65":809,"_67":68,"_439":482,"_441":18,"_118":338,"_82":83,"_442":810},{"_63":765,"_65":766,"_67":68,"_439":474,"_441":18,"_118":338,"_82":83,"_442":767},{"_63":722,"_65":723,"_67":68,"_439":451,"_441":18,"_118":338,"_82":83,"_442":724},{"_63":678,"_65":679,"_67":68,"_439":680,"_441":18,"_118":338,"_82":83,"_442":681},{"_63":635,"_65":636,"_67":68,"_439":637,"_441":18,"_118":338,"_82":83,"_442":638},{"_63":591,"_65":592,"_67":68,"_439":593,"_441":18,"_118":338,"_82":83,"_442":594},{"_63":547,"_65":548,"_67":68,"_439":549,"_441":18,"_118":338,"_82":83,"_442":550},{"_63":503,"_65":504,"_67":68,"_439":505,"_441":18,"_118":338,"_82":83,"_442":506},{"_63":437,"_65":438,"_67":68,"_439":440,"_441":18,"_118":338,"_82":83,"_442":443},"796900ca-8be4","Section 8 - AI Part 3","order",10,"isPrivate","lessons",[444,445,446,447,448],{"_63":496,"_65":497,"_67":68,"_439":127,"_441":18,"_452":498,"_453":437,"_454":499,"_456":500,"_458":-5,"_459":501,"_461":502,"_463":464,"_465":466,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":488,"_65":489,"_67":68,"_439":490,"_441":18,"_452":491,"_453":437,"_454":492,"_456":493,"_458":-5,"_459":494,"_461":495,"_463":464,"_465":466,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":480,"_65":481,"_67":68,"_439":482,"_441":18,"_452":483,"_453":437,"_454":484,"_456":485,"_458":-5,"_459":486,"_461":487,"_463":464,"_465":466,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":472,"_65":473,"_67":68,"_439":474,"_441":18,"_452":475,"_453":437,"_454":476,"_456":477,"_458":-5,"_459":478,"_461":479,"_463":464,"_465":466,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":449,"_65":450,"_67":68,"_439":451,"_441":18,"_452":-5,"_453":437,"_454":455,"_456":457,"_458":-5,"_459":460,"_461":462,"_463":464,"_465":466,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},"05bfcc34-1a2a","8.5 - Building the UI with Claude Code Part 3",4,"content","sectionId","links",[],"downloads",[],"videoUrl","videoHostedId","d95f2b3c-92ff-43be-8161-d56714495476","videoDuration",321,"videoWidth",3840,"videoHeight",2160,"videoDownloadable","videoStatus","ready","isPublicPreview","embedCode","6800ecdc-9518","8.4 - Building the UI with Claude Code Part 2",3,"```text\nonly comment, can we not send all client code down at once in a single request to index.html?\n```",[],[],"35516ace-df78-409f-af49-99a8db55ef93",374,"19a8fca7-1cbd","8.3 - Building the UI with Claude Code Part 1",2,"The rest of this lesson is using AI to build out a frontend.\n\nI used a pretty outdated version of Claude Code as the outcome I needed was not that complex.\n\n> [!tip]\n> I recommend starting with plan mode when you have a larger build\n\n```text\nbuild out index.html. This is a demo app, at most you can one html file here, a css file, and a js file if \n needed. This is a SPA with this structure: a sidebar to list out the lessons and display them (render the \n markdown content). NO CRUD capability is needed. On top of side bar we will have one page which is chat \n which will be used to talk to the LLM. Do not stream right now, just get a single send with POST to our \n endpoint, and show the response after it loads. chat will just have an input a send button and message \n bubbles. all styling in dedicated css file for separation.\n```",[],[],"968e3cdc-095b-4a8d-898a-75ba77033c43",490,"adf52ac8-ac55","8.2 - FastAPI Setup",1,"This ends up being our file structure:\n\n![](https://course-catalyst-pull-zone.b-cdn.net/photos/NWRjZDgzMDct/lesson-migration/2026/07/tP5NrFM0OI4M.png)\n\n```python\nfrom pathlib import Path\n\nfrom fastapi import FastAPI, HTTPException\nfrom fastapi.responses import FileResponse\nfrom pydantic import BaseModel\n\nfrom ai.llm import answer\n\napp = FastAPI(title=\"Caleb GPT\")\n\npath = Path(__file__).parent / \"static\"\nlessons_path = Path(__file__).parent.parent / \"lessons\"\n\n\n@app.get(\"/\")\ndef index():\n return FileResponse(path / \"index.html\")\n\n\n@app.get(\"/api/lessons\")\ndef get_lessons():\n lesson_files = sorted(lessons_path.glob(\"lesson-*.md\"))\n lessons = []\n for file in lesson_files:\n lesson_id = file.stem.replace(\"lesson-\", \"\")\n with open(file, \"r\") as f:\n first_line = f.readline().strip()\n title = first_line.replace(\"#\", \"\").strip() if first_line.startswith(\"#\") else file.stem\n lessons.append({\"id\": lesson_id, \"title\": title, \"filename\": file.name})\n return {\"lessons\": lessons}\n\n\n@app.get(\"/api/lessons/{lesson_id}\")\ndef get_lesson(lesson_id: str):\n lesson_file = lessons_path / f\"lesson-{lesson_id}.md\"\n if not lesson_file.exists():\n raise HTTPException(status_code=404, detail=\"Lesson not found\")\n with open(lesson_file, \"r\") as f:\n content = f.read()\n return {\"content\": content}\n\n\nclass ChatRequest(BaseModel):\n question: str\n\n\n@app.post(\"/chat\")\ndef chat(req: ChatRequest):\n response = answer(req.question)\n # Response is now a dict with content, sources, and token_usage\n return response\n\n```",[],[],"80fe723c-ffe9-4882-b0ee-dbf2bff496c8",511,"ad0814d6-46aa","8.1 - Vector Search","This section doesn’t have a ton of written notes. Majority is just setting up a web project and then utilizing AI to build out a very basic frontend.\n\n```python\nfrom openai import OpenAI\nfrom embedder import embed\nfrom init import connect, settings\n\nllm = OpenAI(base_url=str(settings.llm_base_url), api_key=\"example\")\n\n\ndef search(search_string: str):\n vector = embed([search_string])[0]\n conn = connect()\n with conn.cursor() as cursor:\n cursor.execute(\n \"\"\"\n SELECT content, section, lesson, embedding <=> %s::vector as distance \n FROM embeddings\n ORDER BY embedding <=> %s::vector \n LIMIT 10\n \"\"\",\n (vector, vector),\n )\n\n result = cursor.fetchall()\n conn.close()\n\n return result\n\n\ndef answer(question: str):\n rows = search(question)\n\n system = \"\"\"\n Answer the prompt using only the relevant information from the lesson excerpts below.\n Each excerpt will be of the format [lesson > section]. Don't JUST give the source, but use the source to craft an answer and cite.\n Respond saying which section your answer came from following this format, like [lesson01 > How to water plants] (distance)\n If the answer is not in the excerpts explicitly say so. Avoid general knowledge and source everything. \n \"\"\"\n\n context = \"\\n\\n\".join(\n [\n f\"[{lesson} > {section}] ({distance}) {content}\"\n for content, section, lesson, distance in rows\n ]\n )\n\n # print(system + context)\n response = llm.chat.completions.create(\n model=settings.llm_model,\n messages=[\n {\"role\": \"system\", \"content\": system + context},\n {\"role\": \"user\", \"content\": question},\n ],\n )\n return response.choices[0].message.content\n\n\nprint(answer(\"How do I take care of my plants?\"))\n\n```",[],[],"861fc69c-1fa1-4277-95d6-c476f09dfcb0",829,"c0154c31-c803","Section 7 - AI Part 2",9,[507,508,509,510,511],{"_63":540,"_65":541,"_67":68,"_439":127,"_441":18,"_452":542,"_453":503,"_454":543,"_456":544,"_458":-5,"_459":545,"_461":546,"_463":464,"_465":466,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":533,"_65":534,"_67":68,"_439":490,"_441":18,"_452":535,"_453":503,"_454":536,"_456":537,"_458":-5,"_459":538,"_461":539,"_463":464,"_465":466,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":526,"_65":527,"_67":68,"_439":482,"_441":18,"_452":528,"_453":503,"_454":529,"_456":530,"_458":-5,"_459":531,"_461":532,"_463":464,"_465":466,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":519,"_65":520,"_67":68,"_439":474,"_441":18,"_452":521,"_453":503,"_454":522,"_456":523,"_458":-5,"_459":524,"_461":525,"_463":464,"_465":466,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":512,"_65":513,"_67":68,"_439":451,"_441":18,"_452":514,"_453":503,"_454":515,"_456":516,"_458":-5,"_459":517,"_461":518,"_463":464,"_465":466,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},"2f63781a-cff2","7.5 - Insert our Embeddings","I’ll keep this pretty simple.\n\n```python\n# clear the db to reembed\nconn = connect()\nwith conn.cursor() as cursor:\n cursor.execute(\"TRUNCATE embeddings\")\n conn.commit()\n conn.close()\n\nfor file in sorted((Path(__file__).parent / \"lessons\").glob(\"*.md\")):\n chunks = parse_and_chunk(file)\n\n current_title = \"Unknown\"\n for chunk in chunks:\n orig_elements = chunk.metadata.orig_elements\n titles = (\n [elem.text for elem in orig_elements if elem.category == \"Title\"]\n if orig_elements\n else []\n )\n if titles:\n title = titles[0]\n current_title = titles[0]\n else:\n title = current_title\n\n vector = embed([chunk.text])[0]\n conn = connect()\n with conn.cursor() as cursor:\n cursor.execute(\n \"INSERT INTO embeddings (embedding, section, lesson, content) VALUES (%s, %s, %s, %s)\",\n (vector, title, chunk.metadata.filename, chunk.text),\n )\n conn.commit()\n conn.close()\n print(f\"{chunk.metadata.filename} -> {title}\")\n print(chunk.text[:30])\n\n```",[],[],"4637fc7c-788f-46fb-ae43-0d799a8b2a6d",336,"ecb22c20-cf5c","7.4 - Processing our Documents","I used AI to generate some `.md` files.\n\nThis uses some code to figure out the original section title.\n\n```python\nfrom pathlib import Path\n\nfrom unstructured.partition.md import partition_md\nfrom unstructured.chunking.title import chunk_by_title\n\n\ndef parse_and_chunk(filepath):\n elements = partition_md(filepath)\n\n chunks = chunk_by_title(\n elements, max_characters=800, overlap=150, combine_text_under_n_chars=50\n )\n\n return chunks\n\n\nfor file in sorted((Path(__file__).parent / \"lessons\").glob(\"*.md\")):\n chunks = parse_and_chunk(file)\n\n current_title = \"Unknown\"\n for chunk in chunks:\n orig_elements = chunk.metadata.orig_elements\n titles = (\n [elem.text for elem in orig_elements if elem.category == \"Title\"]\n if orig_elements\n else []\n )\n if titles:\n title = titles[0]\n current_title = titles[0]\n else:\n title = current_title\n print(f\"{chunk.metadata.filename} -> {title}\")\n print(chunk.text[:30])\n\n```",[],[],"8406fac8-3e97-45ff-9363-e55896386b69",734,"25e5488d-91a8","7.3 - Creating a Markdown Parser","In this lesson we created `parser.py` which uses unstructured to split up our markdown lessons.\n\n```python\nfrom pathlib import Path\n\nfrom unstructured.partition.md import partition_md\nfrom unstructured.chunking.title import chunk_by_title\n\n\ndef parse_and_chunk(filepath):\n elements = partition_md(filepath)\n\n chunks = chunk_by_title(\n elements, max_characters=800, overlap=150, combine_text_under_n_chars=100\n )\n\n return chunks\n\n\nchunks = parse_and_chunk(Path(__file__).parent / \"lessons/lesson-01.md\")\n\nfor chunk in chunks:\n print(chunk)\n\n```\n\nOur parsing strategy is to split by section but also cap by 800 characters and overlap by 150.\n\nIf you need more granularity, reduce the character count.\n\nI’d recommend reading through this doc:\n\n[Chunking - Unstructured](https://docs.unstructured.io/open-source/core-functionality/chunking)",[],[],"9113b15c-0009-4009-8c5e-d8d2d74804fd",423,"6efe8ecd-78ad","7.2 - Similarity Search","This uses `<=>` which is called cosine distance.\n\n> [!tip]\n> Notes from AI: This is cosine **distance**, not cosine **similarity**. They're related:\n> Cosine similarity = 1 - (cosine distance / 2)\n> Cosine distance = 2 * (1 - cosine similarity)\n> The other pgvector operators:\n> `<->` = L2/Euclidean distance\n> `<#>` = Negative inner product\n> `<+>` = L1/Manhattan distance (pgvector 0.5.0+)\n\n```python\nsearch = \"The plant needs watered twice a day\"\n\nvector = embed([search])[0]\nconn = connect()\nwith conn.cursor() as cursor:\n cursor.execute(\n \"\"\"\n SELECT content, section, lesson, embedding <=> %s::vector as distance \n FROM embeddings\n ORDER BY embedding <=> %s::vector \n LIMIT 10\n \"\"\",\n (vector, vector),\n )\n\n result = cursor.fetchall()\n conn.close()\n\n for r in result:\n print(r)\n\n```\n\nWe then inserted multiple example values to see what would happen:\n\n```python\nphrases = [\n \"The cat sleeps on the warm windowsill\",\n \"Coffee brewing in the morning sunlight\",\n \"Raindrops falling on autumn leaves\",\n \"Children playing in the neighborhood park\",\n \"Fresh bread cooling on the kitchen counter\",\n \"Birds singing at dawn's first light\",\n \"Ocean waves crashing against rocky shores\",\n \"Snow covering the mountain peaks\",\n \"Books stacked high on wooden shelves\",\n \"Garden flowers blooming in springtime\",\n \"Train whistling through the countryside\",\n \"Stars twinkling in the midnight sky\",\n \"Dogs barking at passing strangers\",\n \"Wind chimes dancing in the breeze\",\n \"Pizza delivery arriving just in time\",\n \"Thunder rumbling across dark clouds\",\n \"Bicycle wheels spinning down the path\",\n \"Campfire crackling under starry skies\",\n \"Music drifting from an open window\",\n \"Leaves rustling in the autumn wind\",\n]\n\n\nvectors = embed(phrases)\nconn = connect()\nwith conn.cursor() as cursor:\n for content, vector in zip(phrases, vectors):\n cursor.execute(\n \"INSERT INTO embeddings (embedding, section, lesson, content) VALUES (%s, %s, %s, %s)\",\n (vector, \"test section\", \"test lesson\", content),\n )\n conn.commit()\n conn.close()\n```\n\nfor the search term `The plant needs watered twice a day` This gives us:\n\n```python\n('The plant needs watered twice a day', 'test section', 'test lesson', 0.0)\n('Garden flowers blooming in springtime', 'test section', 'test lesson', 0.4669089952815625)\n('Coffee brewing in the morning sunlight', 'test section', 'test lesson', 0.4920564908846602)\n('Raindrops falling on autumn leaves', 'test section', 'test lesson', 0.5019336043635622)\n('Leaves rustling in the autumn wind', 'test section', 'test lesson', 0.5298046678886799)\n(\"Birds singing at dawn's first light\", 'test section', 'test lesson', 0.5435144823465604)\n('Children playing in the neighborhood park', 'test section', 'test lesson', 0.5727612544128968)\n('The cat sleeps on the warm windowsill', 'test section', 'test lesson', 0.5765016976283379)\n('Campfire crackling under starry skies', 'test section', 'test lesson', 0.5787927979746286)\n('Bicycle wheels spinning down the path', 'test section', 'test lesson', 0.5796332277616338)\n```\n\n`0.0` is identical, and the closer to zero the more relevant the info.\n\nThere is semantic interpretation done here. So garden and plant might be seen as close even if they’re not exactly the same (this behavior is through the embedder model).",[],[],"1a61bb79-ff7a-4835-89f9-65f48cca2d38",481,"95409145-b1e5","7.1 - Insert Vectors in to Database","In the previous section we started building the embedding code.\n\nWe’re going to start off by creating a function to embed multiple values.\n\n```python\n\ndef embed(text: list[str]):\n response = embedder.embeddings.create(model=settings.embedder_model, input=text)\n return [data.embedding for data in response.data]\n\n```\n\nThe way you would use this:\n\n```python\ncontent = \"The plant needs watered twice a day\"\nvector = embed([content])[0]\n```\n\nWe then talked about inserting this in to the database. We started off by creating some db initialization code in `init.py`.\n\n```python\nimport psycopg\nfrom pydantic import Field, HttpUrl\nfrom pydantic_settings import BaseSettings, SettingsConfigDict\nfrom pgvector.psycopg import register_vector\n\n\nclass Settings(BaseSettings):\n llm_base_url: HttpUrl = Field(init=False)\n llm_model: str = Field(init=False)\n embedder_base_url: HttpUrl = Field(init=False)\n embedder_model: str = Field(init=False)\n database_url: str = Field(init=False)\n model_config = SettingsConfigDict(env_file=\".env\", case_sensitive=False)\n\n\nsettings = Settings()\n\n\ndef connect():\n conn = psycopg.connect(settings.database_url)\n register_vector(conn)\n return conn\n\n```\n\nWe then insert some data:\n\n```python\n# insert one\ncontent = \"The plant needs watered twice a day\"\nvector = embed([content])[0]\nconn = connect()\nwith conn.cursor() as cursor:\n cursor.execute(\n \"INSERT INTO embeddings (embedding, section, lesson, content) VALUES (%s, %s, %s, %s)\",\n (vector, \"test section\", \"test lesson\", content),\n )\n conn.commit()\n conn.close()\n\n```\n\nNow that the data is inserted we need a way to search for similarities with new data.",[],[],"7d299e0e-d814-4e10-aa42-8e5f63828f7b",477,"7eaa48c4-8131","Section 6 - AI Part 1",8,[551,552,553,554,555],{"_63":584,"_65":585,"_67":68,"_439":127,"_441":18,"_452":586,"_453":547,"_454":587,"_456":588,"_458":-5,"_459":589,"_461":590,"_463":464,"_465":466,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":577,"_65":578,"_67":68,"_439":490,"_441":18,"_452":579,"_453":547,"_454":580,"_456":581,"_458":-5,"_459":582,"_461":583,"_463":464,"_465":466,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":570,"_65":571,"_67":68,"_439":482,"_441":18,"_452":572,"_453":547,"_454":573,"_456":574,"_458":-5,"_459":575,"_461":576,"_463":464,"_465":466,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":563,"_65":564,"_67":68,"_439":474,"_441":18,"_452":565,"_453":547,"_454":566,"_456":567,"_458":-5,"_459":568,"_461":569,"_463":464,"_465":466,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":556,"_65":557,"_67":68,"_439":451,"_441":18,"_452":558,"_453":547,"_454":559,"_456":560,"_458":-5,"_459":561,"_461":562,"_463":464,"_465":466,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},"b2b063a9-d4eb","6.5 - Creating Embeddings","We first structure our project like so:\n\n![](https://course-catalyst-pull-zone.b-cdn.net/photos/NWRjZDgzMDct/lesson-migration/2026/07/tu0Dq7r85fCR.png)\n\nThe [`init.py`](http://init.py) file is designed to be our initialization code that runs one time at startup.\n\nWhen Ollama is running we can see the details of available models here:\n\n[http://localhost:11434/api/tags](http://localhost:11434/api/tags)\n\nThis can be used to see the capabilities.\n\nFor example:\n\n```json\n{\n \"name\": \"nomic-embed-text:latest\",\n \"model\": \"nomic-embed-text:latest\",\n \"modified_at\": \"2026-06-18T17:56:38.720185464-04:00\",\n \"size\": 274302450,\n \"digest\": \"0a109f422b47e3a30ba2b10eca18548e944e8a23073ee3f3e947efcf3c45e59f\",\n \"details\": {\n \"parent_model\": \"\",\n \"format\": \"gguf\",\n \"family\": \"nomic-bert\",\n \"families\": [\n \"nomic-bert\"\n ],\n \"parameter_size\": \"137M\",\n \"quantization_level\": \"F16\",\n \"context_length\": 2048,\n \"embedding_length\": 768\n },\n \"capabilities\": [\n \"embedding\"\n ]\n }\n```\n\nYou’ll notice the `capabilitlies`. I was having issues with a Qwen model as it was missing certain capabilities, so I went with `nomic-embed-text`.\n\n[Alibaba-NLP/gte-Qwen2-1.5B-instruct · Hugging Face](https://huggingface.co/Alibaba-NLP/gte-Qwen2-1.5B-instruct)\n\n[nomic-ai/nomic-embed-text-v1.5 · Hugging Face](https://huggingface.co/nomic-ai/nomic-embed-text-v1.5)\n\nWe will use this version:\n\n```text\nollama pull nomic-embed-text \n```\n\nI run it from my main directory with:\n\n```text\n\ndocker exec -i ai-db psql -U postgres -d ai-db < ai/schema.sql\n```\n\nAn example of generating embeddings.\n\n```python\nfrom init import settings\nfrom openai import OpenAI\nimport psycopg\n\nembedder = OpenAI(base_url=str(settings.embedder_base_url), api_key=\"example\")\n\n\ndef embed_text(text: str):\n response = embedder.embeddings.create(model=settings.embedder_model, input=\"text\")\n return response.data[0].embedding\n\n\nprint(embed_text(\"hello\"))\n\n```\n\nWe’ve got everything prepared, and even installed `psycopg2-binary` to start working with the database. That’s where we’ll start next.",[],[],"18a5599d-3cf0-4fdb-9a89-4bc61fe112f8",605,"ac5c95ce-b947","6.4 - Embedding Models","> An embedding is a vector (list) of floating point numbers. The [**distance**](https://developers.openai.com/api/docs/guides/embeddings#which-distance-function-should-i-use) between two vectors measures their relatedness. Small distances suggest high relatedness and large distances suggest low relatedness.\n> [Vector embeddings | OpenAI API](https://developers.openai.com/api/docs/guides/embeddings)\n\nAgain we will go with OpenAI compatibility with embeddings. The main thing that matters here is the dimension matching.\n\nYou can explore model types on Hugging Face.\n\nA very quick intro to model types, for embeddings we want to look out for `gte` which stands for general text embeddings. You’ll often find multiple quantizations which use lower resolution numbers (for example 4 bit instead of 16). When working with Ollama you’ll look out for GGUF.\n\n```sql\nCREATE EXTENSION IF NOT EXISTS vector;\n\nCREATE TABLE IF NOT EXISTS embeddings (\n id int GENERATED ALWAYS AS IDENTITY PRIMARY KEY,\n embedding VECTOR(768) NOT NULL,\n lesson TEXT NOT NULL,\n section TEXT NOT NULL,\n content TEXT NOT NULL\n);\n```\n\n> [!tip]\n> We started with 1536 but end up changing to 768 in the next lesson.\n\nThis schema allows us to associate some embeddings to a lesson and section (for linking) and the content it is referring to.\n\nI also created a lesson in `lessons/lesson-01.md`:\n\n```text\n# This is a title\n\nThis is the content\n\n## Subtitles\n\nmore content\n\n```",[],[],"06cdb370-21d2-4ce5-ab97-5ce96426b48d",471,"b0113543-4452","6.3 - Vector Databases and RAG","[Retrieval-augmented generation](https://en.wikipedia.org/wiki/Retrieval-augmented_generation)\n\n[pgvector/pgvector - Docker Image](https://hub.docker.com/r/pgvector/pgvector)\n\nWe started off by first using `HttpUrl` for better runtime checking of our environment variables.\n\n```python\nclass Settings(BaseSettings):\n llm_base_url: HttpUrl = Field(init=False)\n model_config = SettingsConfigDict(env_file=\".env\", case_sensitive=False)\n\n\nsettings = Settings()\n\n\nllm = OpenAI(base_url=str(settings.llm_base_url), api_key=\"example\")\n\n```\n\nI created a `readme.md` to keep some of our most important commands:\n\n````markdown\nLet's start the db:\n\n```\ndocker run -d --name ai-db \\\n-e POSTGRES_PASSWORD=password \\\n-e POSTGRES_DB=ai-db \\\n-p 5455:5432 \\\npgvector/pgvector:pg18\n```\n\nRun SQL\n\n```\ndocker exec -i ai-db psql -U postgres -d ai-db < schema.sql\n```\n\n````\n\nThis creates a Postgres container with the pgvector extension, exposed on port 5455 (as I don’t want it to conflict with any other Postgres containers I am running).\n\nWe haven’t yet defined the schema, let’s do that now.",[],[],"78bf8bd2-5a03-443a-8c50-bad2b8f22330",503,"bf2fe298-0475","6.2 - Pydantic Environment Variables","We will create a `.env` file:\n\n```text\nLLM_BASE_URL=http://localhost:11434/v1\n```\n\n[Settings Management](https://pydantic.dev/docs/validation/latest/concepts/pydantic_settings/)\n\n```python\nfrom openai import OpenAI\nfrom pydantic import Field\nfrom pydantic_settings import BaseSettings, SettingsConfigDict\n\n\nclass Settings(BaseSettings):\n llm_base_url: str = Field(init=False)\n model_config = SettingsConfigDict(env_file=\".env\", case_sensitive=False)\n\n\nsettings = Settings()\n\n\nllm = OpenAI(base_url=settings.llm_base_url, api_key=\"example\")\n\nresponse = llm.chat.completions.create(\n model=\"llama3.2:3b\", messages=[{\"role\": \"user\", \"content\": \"tell me a joke\"}]\n)\n\nprint(response.choices[0].message.content)\n\n```\n\nFor this it reads from the current working directory (`pwd` on Unix). So, make sure you move the location of your `.env` or run from the same directory as this file.",[],[],"d2bb9d9c-1cd0-40cf-bac8-791f2e12e758",461,"ae43ad5f-cfa3","6.1 - AI Overview","We will be using pre-trained models for generative AI to give users an enhanced experience.\n\nExample will be enhanced learning experience for documentation or courses.\n\n```python\nollama pull llama3.2:3b\n```\n\nOllama exposes an Openai compatible API at `http://localhost:11434/v1`\n\n```python\nfrom openai import OpenAI\n\nllm = OpenAI(base_url=\"http://localhost:11434/v1\", api_key=\"example\")\n\nresponse = llm.chat.completions.create(\n model=\"llama3.2:3b\", messages=[{\"role\": \"user\", \"content\": \"tell me a joke\"}]\n)\n\nprint(response.choices[0].message.content)\n\n```",[],[],"490bdd74-4118-4b23-b647-670c5b3b2fbf",497,"d01370c7-5113","Section 5 - Advanced Topics",7,[595,596,597,598,599],{"_63":628,"_65":629,"_67":68,"_439":127,"_441":18,"_452":630,"_453":591,"_454":631,"_456":632,"_458":-5,"_459":633,"_461":634,"_463":464,"_465":466,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":621,"_65":622,"_67":68,"_439":490,"_441":18,"_452":623,"_453":591,"_454":624,"_456":625,"_458":-5,"_459":626,"_461":627,"_463":464,"_465":466,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":614,"_65":615,"_67":68,"_439":482,"_441":18,"_452":616,"_453":591,"_454":617,"_456":618,"_458":-5,"_459":619,"_461":620,"_463":464,"_465":466,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":607,"_65":608,"_67":68,"_439":474,"_441":18,"_452":609,"_453":591,"_454":610,"_456":611,"_458":-5,"_459":612,"_461":613,"_463":464,"_465":466,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":600,"_65":601,"_67":68,"_439":451,"_441":18,"_452":602,"_453":591,"_454":603,"_456":604,"_458":-5,"_459":605,"_461":606,"_463":464,"_465":466,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},"d0943060-fc3f","5.5 - Threading","Threads are easier to work with in my opinion as they don’t require you change all calling functions and allow you to get the benefit of concurrency even if a library is not async/await compatible.\n\n```python\nimport httpx\nimport threading\n\n\ndef fetch(sem):\n with sem:\n response = httpx.get(\"http://localhost:8000\", timeout=30)\n print(response.json())\n \n\nsem = threading.Semaphore(5)\n\nfor _ in range(3000):\n threading.Thread(target=fetch, args=(sem,)).start()\n\nprint(\"Continuing\")\n\n```\n\nThis above works but produced a thread each time, when we can use the thread as an ongoing thing that just processes new data.\n\nFor this we will use a queue and process anything left in the queue. A very common structure for message brokers and things like rabbitmq.\n\nWe can set a maxsize on a queue to prevent out of memory errors. A queue acts as a buffer but should not be seen as a place to put unlimited information.\n\n```python\nimport httpx\nimport threading\nfrom queue import Queue\n\nq = Queue(maxsize=5000)\n\n\ndef worker():\n while True:\n i = q.get()\n response = httpx.get(\"http://localhost:8000\", timeout=30)\n print(i, response.json())\n\n q.task_done()\n\n\nfor _ in range(5):\n threading.Thread(target=worker).start()\n\nfor i in range(3000):\n q.put(i)\n\nprint(\"Continuing\")\n```\n\nThe next logical step in your learning journey would be learning about parallel execution within Python and also some challenges like deadlock, etc.",[],[],"a01c75e8-11ae-442c-9465-5d8b81ef5c79",611,"e99ca6a3-d398","5.4 - Concurrency","Concurrency can be done with multiple threads executing in parallel, but it can also be tasks sharing execution time on a single thread. This is especially common for things that are not tying up the CPU, such as network requests.\n\nFor this example I set up a dead-simple server with FastAPI, in `server.py`.\n\n```python\nimport asyncio\nimport random\nfrom fastapi import FastAPI\n\napp = FastAPI()\n\n\n@app.get(\"/\")\nasync def root():\n wait = random.randint(1, 10)\n print(\"waiting\", wait)\n await asyncio.sleep(wait)\n return {\"waited\": wait}\n\n```\n\n```text\nuv add \"fastapi[standard]\"\n```\n\n```text\nuv run fastapi dev 5/server.py\n```\n\n```python\nimport httpx\nimport asyncio\n\n\nasync def main():\n async with httpx.AsyncClient() as client:\n tasks = [client.get(\"http://localhost:8000\", timeout=30) for _ in range(3)]\n\n responses = await asyncio.gather(*tasks)\n for response in responses:\n print(response.json())\n\n\nprint(\"Continue executing\")\nasyncio.run(main())\n```\n\nThis sets things up to easily be executed concurrently with coroutines, but it is still synchronous.\n\nTo make it asynchronous we will use `asyncio` and the async support within `httpx`.\n\n```python\nimport httpx\nimport asyncio\n\n\nasync def main():\n async with httpx.AsyncClient() as client:\n tasks = [client.get(\"http://localhost:8000\", timeout=30) for _ in range(3)]\n\n for response in asyncio.as_completed(tasks):\n print((await response).json())\n\n\nprint(\"Continue executing\")\nasyncio.run(main())\n\n```\n\nLastly, we can limit the number of requests at any given time using a semaphore.\n\n```python\nimport httpx\nimport asyncio\n\n\nasync def fetch(client, sem):\n async with sem:\n response = await client.get(\"http://localhost:8000\", timeout=30)\n return response\n\n\nasync def main():\n sem = asyncio.Semaphore(5)\n async with httpx.AsyncClient() as client:\n tasks = [fetch(client, sem) for _ in range(300)]\n\n for response in asyncio.as_completed(tasks):\n print((await response).json())\n\n\nprint(\"Continue executing\")\nasyncio.run(main())\n```\n\nThreads can be used instead of coroutines to achieve similar results, but give added flexibility say if a certain library we are using doesn’t support async await.",[],[],"34daddd0-9201-4f7f-a987-4e6dade482ea",909,"1ccc4adf-0857","5.3 - Signatures and Encryption","Adding a signature to a message validates that it was sent from the sender you expect. It does not hide the data. If you want to hide the data, that’s where encryption comes in.\n\nBoth examples here are symmetric, meaning the sender and the receiver both need the same key/secret.\n\n```python\n\nimport hmac\nfrom cryptography.fernet import Fernet\n\n# signatures\n# these do not HIDE any data\n\nsecret = b\"top-secret-key-dont-share\"\n\n# sender side:\nmessage = b\"hello\"\nsignature = hmac.new(secret, message, hashlib.sha256).hexdigest()\n# what gets sent? the message, and the signature\n# the key is known on both sides, but NOT shared through the sent message\n# receiving side:\nexpected = hmac.new(secret, b\"different\", hashlib.sha256).hexdigest()\nprint(hmac.compare_digest(signature, expected))\n\n# encryption\n\nkey = Fernet.generate_key()\nf = Fernet(key)\n\n# sending side:\n\nencrypted = f.encrypt(b\"hello\")\n\n# receiving side:\nmessage = f.decrypt(encrypted)\nprint(message)\n```",[],[],"a941932a-d7eb-48c5-a499-d231beb976a8",463,"0477f3ce-8aaa","5.2 - UUIDs and Hashing","## Unique IDs\n\nUnique value generation:\n\n```python\nimport uuid\n\nprint(uuid.uuid4())\n```\n\nYou can use `.hex` to remove dashes.\n\nImportant for distributed database primary keys. Often you’ll be required to create the value in code as if the database is sharded it may not have an anto-incremented ID. That’s why it’s so common with NoSQL. The Db may generate the UUID at the db level, though.\n\nThere’s a lot of variations, such as `uuid1`.\n\n```python\nprint(uuid.uuid1())\n```\n\n[When should I use uuid.uuid1() vs. uuid.uuid4() in python?](https://stackoverflow.com/questions/1785503/when-should-i-use-uuid-uuid1-vs-uuid-uuid4-in-python)\n\n> [!tip]\n> The `uuid1` is similar to a snowflake with some minor differences. A snowflake is 64 bit while `uuid1` is 128.\n> [Snowflake ID](https://en.wikipedia.org/wiki/Snowflake_ID)\n\nThen there is `uuid7` which is a modern variation that uses randomness instead of the machine’s MAC address.\n\n| Field | Width (bits) | Description |\n| --- | --- | --- |\n| unix_ts_ms | 48 | 48-bit Unix epoch timestamp in milliseconds |\n| version | 4 | The four-bit version number (0111) |\n| rand_a | 12 | 12 bits of sub-millisecond timestamp precision, a monotonicity counter, or pseudo-random data |\n| variant | 2 | The two-bit variant (10) |\n| rand_b | 62 | 62 bits of a monotonicity counter, or pseudo-random data |\n\n[Universally unique identifier](https://en.wikipedia.org/wiki/Universally_unique_identifier)\n\n## Hashes\n\nThese are similar in that it gives a long sequence of characters, but it requires an input. You should think of it instead as a fingerprint of a particular input.\n\nHashes are very important.\n\n[https://stackoverflow.com/questions/460576/hash-code-and-checksum-whats-the-difference](https://stackoverflow.com/questions/460576/hash-code-and-checksum-whats-the-difference)\n\n[CRC32 catches errors, but then what's the point of SHA?](https://crypto.stackexchange.com/questions/74848/crc32-catches-errors-but-then-whats-the-point-of-sha)\n\n[Are checksums essentially non-secure versions of cryptographic hashes?](https://crypto.stackexchange.com/questions/32988/are-checksums-essentially-non-secure-versions-of-cryptographic-hashes)\n\n```python\nimport uuid\nimport hashlib\nimport zlib\n\n## UUID\n\nprint(uuid.uuid7())\n\n## Hashes\n\nprint(hash(\"hello\"))\nprint(hash(\"hello\"))\n# hash should never change\n# list is mutable -> not ideal for hashing\n# print(hash([\"this\", \"is\", \"a\", \"list\"]))\nmessage = b\"hello\"\nprint(hashlib.sha256(message).hexdigest())\n\n# sending over network\nprint(hashlib.sha256(b\"hello\").hexdigest())\n# passwords\n# Store the password and a salt\n\n# Checksum\ndata = b\"hello\"\noriginal = zlib.crc32(data)\n\nreceived = b\"hell\"\nprint(zlib.crc32(received) == original)\n```",[],[],"d88712fd-6bf3-4175-b8ff-8c48d29aca14",853,"af357e98-bcad","5.1 - File System","You should be somewhat comfortable interfacing with the system you are on, but there are a million things you may need to do. Let's first start by getting an overview of the different packages and ideas so you have a better understanding of the big picture.\n\nos - The operating system layer.\n\nThis has an `os.path` but there is `pathlib` for most path manipulation.\n\nsys - The interpreter layer. For example, the module search path. What does the interpreter know about this run?\n\npathlib - path manipulation. Will be important when working with files\n\nasyncio - Concurrency work within Python. We'll look at concurrency in more depth later in this section.\n\nVarious others: subprocess, socket, ssl, etc. Use these if the need comes up. You should be able to pick them up if you're confident in everything we've learned so far.\n\nAlso some external stuff that might be worth looking in to: Typer, pydantic-settings.\n\n## Example\n\nSay we run this command:\n\n```plain text\ngit -C /Users/codebreakthrough/cs/python-mastery log --oneline --author caleb@calebcurry.com\n```\n\nAnd we want to do this within a Python script.\n\nLet's build an example that shows a few different things:\n\n```python\nimport os, sys, subprocess\nfrom pathlib import Path\n\n\ndef main():\n repo = Path(sys.argv[1] if len(sys.argv) > 1 else \".\")\n email = os.getenv(\"EMAIL\", \"\")\n print(f\"checking {repo.resolve()} for {email or 'all'}\")\n\n cmd = [\"git\", \"-C\", repo, \"log\", \"--oneline\"]\n if email:\n cmd += [\"--author\", email]\n\n result = subprocess.run(cmd, capture_output=True, text=True)\n if result.returncode != 0:\n sys.exit(f\"git failed: {result.stderr}\")\n\n print(result.stdout)\n\n\nmain()\n```\n\nThis demonstrates environment variables and command line arguments. We moved up a directory so we could reference the `python-mastery` directory as an example:\n\n```python\ncs % EMAIL=caleb@calebcurry.com uv run \"/Users/codebreakthrough/cs/python-mastery/test.py\" python-mastery \n```\n\n> [!tip]\n> Fallbacks Vs Failure\n> If you want the app to have reasonable defaults, set them in the code. If you want to require values to be passed in, remove the defaults and it will fail without them.\n\nSome important notes:\n\n`repo.resolve()` turns it in to an absolute path for printing, don't think it is needed tho\n\nOr we can create a `.env` file (this should always be git ignored).\n\n```python\nEMAIL=you@example.com\n```\n\n```python\nuv add python-dotenv\n```\n\n```python\nimport os, sys, subprocess\nfrom pathlib import Path\nfrom dotenv import load_dotenv\n\ndef main():\n load_dotenv()\n repo = Path(sys.argv[1] if len(sys.argv) > 1 else \".\")\n email = os.getenv(\"EMAIL\", \"\")\n print(f\"checking {repo.resolve()} for {email or 'all'}\")\n cmd = [\"git\", \"-C\", str(repo), \"log\", \"--oneline\"]\n if email:\n cmd += [\"--author\", email]\n result = subprocess.run(cmd, capture_output=True, text=True)\n if result.returncode != 0:\n sys.exit(f\"git failed: {result.stderr}\")\n print(result.stdout)\n\nmain()\n```\n\n## Typed Env\n\n```python\nuv add pydantic-settings\n```\n\n[Settings Management](https://docs.pydantic.dev/latest/concepts/pydantic_settings/)\n\n```python\nimport sys, subprocess\nfrom pathlib import Path\nfrom pydantic_settings import BaseSettings, SettingsConfigDict\n\nclass Settings(BaseSettings):\n model_config = SettingsConfigDict(env_file=\".env\")\n email: str = \"\"\n\nsettings = Settings()\n\ndef main():\n repo = Path(sys.argv[1] if len(sys.argv) > 1 else \".\")\n print(f\"checking {repo.resolve()} for {settings.email or 'all'}\")\n cmd = [\"git\", \"-C\", str(repo), \"log\", \"--oneline\"]\n if settings.email:\n cmd += [\"--author\", settings.email]\n result = subprocess.run(cmd, capture_output=True, text=True)\n if result.returncode != 0:\n sys.exit(f\"git failed: {result.stderr}\")\n print(result.stdout)\n\nmain()\n```",[],[],"a3de54af-438d-4ee1-800d-5e44c1770e67",889,"6c26f858-0da5","Section 4 - Standard Library",6,[639,640,641,642,643],{"_63":672,"_65":673,"_67":68,"_439":127,"_441":18,"_452":674,"_453":635,"_454":675,"_456":676,"_458":-5,"_459":677,"_461":495,"_463":464,"_465":466,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":665,"_65":666,"_67":68,"_439":490,"_441":18,"_452":667,"_453":635,"_454":668,"_456":669,"_458":-5,"_459":670,"_461":671,"_463":464,"_465":466,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":658,"_65":659,"_67":68,"_439":482,"_441":18,"_452":660,"_453":635,"_454":661,"_456":662,"_458":-5,"_459":663,"_461":664,"_463":464,"_465":466,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":651,"_65":652,"_67":68,"_439":474,"_441":18,"_452":653,"_453":635,"_454":654,"_456":655,"_458":-5,"_459":656,"_461":657,"_463":464,"_465":466,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":644,"_65":645,"_67":68,"_439":451,"_441":18,"_452":646,"_453":635,"_454":647,"_456":648,"_458":-5,"_459":649,"_461":650,"_463":464,"_465":466,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},"1ce086f5-c57b","4.5 - Web Requests and Data Parsing","For web requests you can stick to the standard library but its pretty typical to go outside to get external packages. We’ll show both.\n\n```python\nuv add requests httpx beautifulsoup4\n```\n\n```python\nurl = \"https://docs.python.org/3/library/datetime.html#format-codes\"\n\nwith urlopen(url) as response:\n soup = BeautifulSoup(response.read(), \"html.parser\")\n\nprint(soup.head.title.text) # type: ignore\n\n# get all links\n\nfor link in soup.body.find_all(\"a\"): # type: ignore\n print(link.get(\"href\"))\n```\n\n> [!tip]\n> Building a full web crawler could be a fabulous project if you want something more challenging and applied. \n> Start here to learn about the architecture:\n> [Design a Web Crawler | Hello Interview System Design in a Hurry](https://www.hellointerview.com/learn/system-design/problem-breakdowns/web-crawler)\n\nHere is a request without external dependencies:\n\n```python\nfrom urllib.request import urlopen\nimport json\n\nurl = \"https://openlibrary.org/search.json?q=python+programming\"\n\nwith urlopen(url) as response:\n data = json.loads(response.read())\n```\n\nFor JSON data it’s common to see `requests` or `httpx`:\n\n```python\nurl = \"https://openlibrary.org/search.json?q=python+programming\"\n\ndata = httpx.get(url).json()\n# data = requests.get(url).json() # same interface\n```\n\nHere is the easiest way to work with a URL and scrape the content:\n\n```python\nurl = httpx.URL(\"https://openlibrary.org/search.json?q=python+programming\")\nprint(url.host, url.path, url.params)\n\ndata = httpx.get(url).json()\n\nbooks = data.get(\"docs\")[:3]\n\nfor book in books:\n print(book.get(\"title\"), end=\"\\n\\n\")\n\n```\n\nWow here is a 16 year old post on stack overflow at the time of this writing - [What are the differences between the urllib, urllib2, urllib3 and requests module?](https://stackoverflow.com/questions/2018026/what-are-the-differences-between-the-urllib-urllib2-urllib3-and-requests-modul)",[],[],"d41e82bc-3559-434f-b27e-e7054aafb92d",862,"88c621b8-7b21","4.4 - Dates and Times","## Dates and Times\n\n[Python strftime Cheatsheet | BairesDev](https://strftime.org/)\n\n[datetime - Basic date and time types](https://docs.python.org/3/library/datetime.html#format-codes)\n\n[List of tz database time zones](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones)\n\nDatetimes in Python (by default) are not tied to a specific timezone. They get your current system time and that’s it. They don’t know that you may be 4 hours off of UTC.\n\nThis can work if we don’t need to adjust the time for timezones.\n\nWe can also format the dates to appear however we wish.\n\n```python\nfrom datetime import datetime, timezone, date, time\n\nimport time as t\n\nfrom zoneinfo import ZoneInfo, available_timezones\n\ndt = datetime.now()\n\nprint(dt)\n\nprint(dt.strftime(\"%Y-%m-%d %H:%M\"))\n\ndate_string = \"2026-05-01 11:11:00.100000\"\n\ndt2 = datetime.strptime(date_string, \"%Y-%m-%d %H:%M:%S.%f\")\n\nprint(dt2)\n```\n\nIf you only need to work with just dates or just times, you can do that as well.\n\n```python\n## Working with just dates ##\n\nprint(date.today())\n\n## Working with just times ##\n\nprint(datetime.now().time())\n\n\n```\n\nTimestamps are just the count of seconds from Jan 1 1970.\n\n```python\n## timestamps ##\n\nprint(t.time())\n```\n\nThese can come in handy to indicate an exact moment in time.\n\nThings get trickier when we introduce timezones. We will use strings for timezones instead of relative numbers from UTC to prevent issues with daylight savings time.\n\n```python\n## timezones ##\n\ndt_zoned = datetime.now(ZoneInfo(\"America/New_York\"))\nprint(dt_zoned)\n\nprint(dt_zoned.astimezone(ZoneInfo(\"America/Los_Angeles\")))\n\nprint(dt_zoned.astimezone(ZoneInfo(\"UTC\")))\n```\n\nLastly, we can time things, you’ll see this done with `time.time()` and `time.perf_counter()` (recommended).\n\n```python\n## timing things ##\n\n# time before\nstart = t.time()\n\n# do something\ntotal = 0\nfor i in range(100000000):\n total += i\n# time after\nend = t.time()\n\n# do math\nprint(end - start)\n\n\n## perf_counter() ##\n\nstart = t.perf_counter()\n\ntotal = 0\nfor i in range(100000000):\n total += i\n\nend = t.perf_counter()\n\nprint(end - start)\n\n```",[],[],"2000d458-ab86-48b2-9be7-18eff0c76ec8",1076,"89873512-2303","4.3 - Intro to the Standard Library","## Overview of Libraries\n\nThe standard library is **huge**.\n\n[The Python Standard Library](https://docs.python.org/3/library/)\n\nAnd you’ll be able to find some of the most common external libraries on PyPI or other external sites. The official PyPi site has very little on analytics and ranking which I guess is cool but I would prefer at least a recommended or new list.\n\n[PyPI Download Stats](https://pypistats.org/top)\n\n[PackagePopularity](https://wiki.python.org/python/PackagePopularity.html)\n\nWe’ll get some practice with some of the most fundamental standard libraries but we will continue to learn more throughout the rest of this course.\n\n## Random Number Generation\n\nActually a rather complex topic in computer science for something that seems simple on the outside.\n\nRandom number generation.\n\n[Pseudorandom number generator](https://en.wikipedia.org/wiki/Pseudorandom_number_generator)\n\n[random - Generate pseudo-random numbers](https://docs.python.org/3/library/random.html)\n\nThe random module gives us random numbers quickly, but they’re not intended for security purposes. If you just need to pick a random value in code that is usually fine for most use cases. For example, if you need to pick a random flash card in a study app. Not exactly a security concern there.\n\nIt’s built off of this random number generator - [Mersenne Twister](https://en.wikipedia.org/wiki/Mersenne_Twister)\n\nHowever, I wouldn’t use it for generating any kind of secret keys or values you wouldn’t want someone to be able to figure out.\n\nThe random number is a sequence generated from a seed, consider this to be what sets the starting point. While not required you can provide one explicitly.\n\n### Secrets\n\nNo seed provided and is used to generate strong random numbers. So if you have security-sensitive tasks then you should consider the secrets library.\n\n```python\nimport secrets\n\n# Generate a secure random token (hex string)\ntoken = secrets.token_hex(32)\nprint(f\"Token: {token}\")\n```\n\nWe can use `randbelow` to give us a number between 0 up to the parameter (exclusive), so if we wanted to generate a number 1-1000 we could do this:\n\n```python\nimport secrets\n\nnumber = secrets.randbelow(1000) + 1\nprint(number) # 1 to 1000\n```\n\n## Copying Data\n\nYou should be familiar with shallow copying vs deep copying. If we are working with nested objects we most likely want to do a deep copy.\n\n```python\nimport copy\n\noriginal = {\"name\": \"Caleb\", \"scores\": [1, 2, 3]}\nshallow = original.copy() # or copy.copy(original)\n\nshallow[\"scores\"].append(99)\nprint(original[\"scores\"]) # [1, 2, 3, 99] - original was mutated!\n```\n\n```python\nimport copy\n\noriginal = {\"name\": \"Caleb\", \"scores\": [1, 2, 3]}\ndeep = copy.deepcopy(original)\n\ndeep[\"scores\"].append(99)\nprint(original[\"scores\"]) # [1, 2, 3] - original is safe\n```\n\nAlso worth noting that Pydantic has operations for copying, if you’re working with Pydantic objects. With the ability to update specific fields, a common approach if you’re making some partial updates to data.\n\n```python\nfrom pydantic import BaseModel\n\nclass User(BaseModel):\n name: str\n scores: list[int]\n\nuser = User(name=\"Caleb\", scores=[1, 2, 3])\n\nupdated = user.model_copy(update={\"name\": \"Someone Else\"})\nprint(updated) # name='Someone Else' scores=[1, 2, 3]\n```\n\nImagine pending state that can then be saved.\n\n[Models - Pydantic Validation](https://docs.pydantic.dev/latest/concepts/models/#model-copy)\n\nIf you’re working with a Pydantic model you can use the method `model_copy` and `model_copy(deep=True)`.\n\n## String Operations\n\n[string - Common string operations](https://docs.python.org/3/library/string.html)\n\nWe’re given these constants that are a string of a bunch of characters, such as the hex digits. We can use the `in` operator to check inclusion.\n\n```python\nimport string\n\n# The constants\nprint(string.ascii_letters) # abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\nprint(string.digits) # 0123456789\nprint(string.hexdigits) # 0123456789abcdefABCDEF\nprint(string.octdigits) # 01234567\nprint(string.punctuation) # !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~\nprint(string.whitespace) # space, tab, newline, etc.\n\n# Using `in` to check inclusion\nprint(\"a\" in string.ascii_letters) # True\nprint(\"Z\" in string.ascii_lowercase) # False - lowercase only\nprint(\"9\" in string.digits) # True\nprint(\"f\" in string.hexdigits) # True\nprint(\"g\" in string.hexdigits) # False\nprint(\"7\" in string.octdigits) # True\nprint(\"8\" in string.octdigits) # False - octal is 0-7 only\nprint(\"!\" in string.punctuation) # True\nprint(\" \" in string.whitespace) # True\n```",[],[],"9dcc21c1-adaa-4790-8431-7dc141648f45",1086,"c7934135-f76b","4.2 - Running Packages as a Script","This alters the way Python finds the file, the first will work with a single file but you’ll use `-m` with packages.\n\nYou’ll see commonly something like:\n\n```text\npython -m pip install ...\n```\n\nAnd this just translates to “run pip directly as a script”\n\nand it will have an associated `if __name__ == ‘__main__’`.\n\nIf you’ve worked with Django you’ll run Django as a script to generate projects:\n\n```python\npython3 -m django startproject mysite\npython3 -m django runserver\n```\n\nBut you’ll also import django in your projects:\n\n```python\nfrom django.db import models\n```\n\nEventually this will craft a `manage.py` file that you’ll use, and that is a single file you’ll invoke with just python:\n\n```python\npython manage.py runserver\n```\n\nthis is not using the Django framework directly but instead just executing a python file.",[],[],"55d09e59-7cf7-430b-b932-d85e674888d6",228,"dcd54595-1a14","4.1 - Packages and Modules","[6. Modules](https://docs.python.org/3/tutorial/modules.html)\n\n[Glossary](https://docs.python.org/3/glossary.html#term-package)\n\n[Trying to understand the difference between modules, packages, libraries, and frameworks. Tell me where my understanding of them is incorrect. This is from the context of Python.](https://www.reddit.com/r/learnprogramming/comments/1jigmy2/trying_to_understand_the_difference_between/)\n\nTLDR:\n\nFile → module\n\npackage → folder\n\nReally not a big deal. You import and use them the same way, but with packages you might have nesting.\n\n[math - Mathematical functions](https://docs.python.org/3/library/math.html) → module\n\n[email - An email and MIME handling package](https://docs.python.org/3/library/email.html#module-email) → package\n\nYou can import from sub modules:\n\n```python\nfrom email.mime.text import MIMEText\n```\n\nYou should understand how imports work and why `from fibo import *` is bad (pollutes / corrupts your namespace).\n\n## Modules within Packages\n\n[6. Modules](https://docs.python.org/3/tutorial/modules.html#packages)\n\nThe sub imports are tied to the folder structure.\n\nIt’s common to see `__init__.py`. “The `__init__.py` files are required to make Python treat directories containing the file as packages”\n\n## What about Library vs Framework?\n\nThese are more abstract terms used to describe code, and don’t have some Python-specific meaning. We can install a package and that package can be a library.\n\nA framework is the same idea just usually more involved, giving you the tools to build something bigger.\n\nI will probably use the term “library” rather than constantly distinguishing between a package or module. So importing libraries.\n\n## External Packages\n\nYou’ll install packages from PyPI, these are managed by someone other than the Python foundation, and can be updated independently. Compare this to the standard library which are libraries included with Python and get updated with Python.\n\n## Imports and Executable Code\n\n> A module can contain executable statements as well as function definitions. These statements are intended to initialize the module. They are executed only the *first* time the module name is encountered in an import statement. [[1]](https://docs.python.org/3/tutorial/modules.html#id3) (They are also run if the file is executed as a script.)\n> [6. Modules](https://docs.python.org/3/tutorial/modules.html)\n\nIn some languages if you’re publishing a package you’ll be expected to mark it as a library or an executable. In Python there’s no clear distinction, but typically it’ll just be a library with functions you’ll import.\n\n## Running as a Script\n\nusing `if name == 'main'` is a trick to describe code that only runs when executed directly as a script, so that it doesn’t run when we import the code.\n\n```python\nprint(\"This is stdlib.py\")\n\nif __name__ == \"__main__\":\n print(\"This is being ran as a script\")\n\n```\n\n```python\nimport stdlib\n\nprint(\"Hello from main\")\n```\n\nIf I run the stdlib file directly, i get:\n\n```python\nuv run \"/Users/codebreakthrough/cs/python-mastery/4/stdlib.py\"\nThis is stdlib.py\nThis is being ran as a script\n```\n\nBut if I run main only, the `if` does not pass as True.",[],[],"f30e0726-dd0d-4295-8eb7-23d5425c3e84","e30b9208-c42b","Section 3 - Types and Data Validation",5,[682,683,684,685,686],{"_63":715,"_65":716,"_67":68,"_439":127,"_441":18,"_452":717,"_453":678,"_454":718,"_456":719,"_458":-5,"_459":720,"_461":721,"_463":464,"_465":466,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":708,"_65":709,"_67":68,"_439":490,"_441":18,"_452":710,"_453":678,"_454":711,"_456":712,"_458":-5,"_459":713,"_461":714,"_463":464,"_465":466,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":701,"_65":702,"_67":68,"_439":482,"_441":18,"_452":703,"_453":678,"_454":704,"_456":705,"_458":-5,"_459":706,"_461":707,"_463":464,"_465":466,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":694,"_65":695,"_67":68,"_439":474,"_441":18,"_452":696,"_453":678,"_454":697,"_456":698,"_458":-5,"_459":699,"_461":700,"_463":464,"_465":466,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":687,"_65":688,"_67":68,"_439":451,"_441":18,"_452":689,"_453":678,"_454":690,"_456":691,"_458":-5,"_459":692,"_461":693,"_463":464,"_465":466,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},"564e6afd-1ca6","3.5 - Pydantic Validation","This lesson is designed to introduce you to Pydantic, but is not a comprehensive crash course. If you’re already using Pydantic this may be review, and realistically to master this topic you’re going to need a lot more time learning it than just one lesson. We may see it more in future lessons and it is utilized by many other libraries and frameworks.\n\n[Why use Pydantic - Pydantic Validation](https://docs.pydantic.dev/latest/why/) - Brief Intro\n\n[Welcome to Pydantic - Pydantic Validation](https://docs.pydantic.dev/latest/#why-use-pydantic)\n\nPydantic is a library that is heavily used to check types, but it is not a static type checker. Rather, it is a validation library used to check the structure of data at runtime.\n\nNatural next step as it uses type hints.\n\nThis will alter the way we create classes. Instead of placing attributes inside of an `__init__`, we place them at at the class level directly. They look like class level attributes but they’ll actually end up as instance values for the object being instantiated.\n\nPydantic does some magic to generate the proper `__init__` method for us, and we can add in data validation rules.\n\nValidation rules can be used for business logic validation (does a certain value make sense) instead of just data types or checking values statically. This will evaluate data at runtime.\n\nWe can use `field_validator` decorator that will be used in combination with `classmethod`, which is kinda like a static method. You’ll have a single parameter `cls` (by convention but name it whatever) that allows you to access class level attributes. We don’t need it, but we have to use that parameter in a similar way to how we need to define a first parameter for methods (`self`).\n\n**This is a vast topic and if you are taking ANY input from users you’d be wise to validate it. **\n**Read up. **\n\nMany other packages utilize Pydantic, so it’s very likely you’ll see it again. For example, with FastPAI, Pydantic is utilized to validate data passed to your API.\n\n[Features - FastAPI](https://fastapi.tiangolo.com/features/)\n\n```python\nfrom pydantic import BaseModel, Field, field_validator\n\n\nclass Dimensions(BaseModel):\n length: float = Field(gt=0)\n width: float = Field(gt=0)\n height: float = Field(gt=0)\n\n def volume(self) -> float:\n return self.length * self.width * self.height\n\n\nclass Package(BaseModel):\n tracking_id: str\n weight_kg: float = Field(gt=0, le=50)\n dimensions: Dimensions\n fragile: bool = False\n\n @field_validator(\"tracking_id\")\n @classmethod\n def tracking_must_be_valid(cls, v: str) -> str:\n if not v.startswith(\"PKG-\"):\n raise ValueError(\"tracking ID must start with PKG-\")\n return v\n\n\n# valid\nbox = Package(\n tracking_id=\"PKG-12345\",\n weight_kg=2.5,\n dimensions={\"length\": 30, \"width\": 20, \"height\": 15},\n fragile=True,\n)\n\nprint(box.dimensions.volume()) # 9000.0\nprint(box.model_dump())\n```\n\nLater on when parsing data we’ll be able to utilize Pydantic to validate incoming data.\n\nHere is a simple demonstration of that working with a dictionary which can be seen as incoming JSON:\n\n```python\nfrom pydantic import BaseModel, Field, field_validator\n\n\nclass Dimensions(BaseModel):\n length: float = Field(gt=0)\n width: float = Field(gt=0)\n height: float = Field(gt=0)\n\n def volume(self) -> float:\n return self.length * self.width * self.height\n\n\nclass Package(BaseModel):\n tracking_id: str\n weight: float = Field(gt=0, lt=100)\n dimensions: Dimensions\n fragile: bool = False\n\n @field_validator(\"tracking_id\")\n @classmethod\n def tracking_must_be_valid(cls, tracking_id: str) -> str:\n if not tracking_id.startswith(\"PKG-\"):\n raise ValueError(\"Must start with PKG-\")\n return tracking_id\n\n\ndim = Dimensions(length=10, width=5, height=3.3)\nbox = Package(tracking_id=\"PKG-123\", weight=5, dimensions=dim, fragile=True)\n\ndata = {\n \"tracking_id\": \"P999\",\n \"weight\": 60,\n \"dimensions\": {\"length\": 30, \"width\": -5, \"height\": 15},\n \"fragile\": True,\n}\n\ntry:\n Package.model_validate(data)\n # do whatever we want with the data\nexcept Exception as e:\n print(e)\n\n```\n\n## Typed Collections\n\n```python\nclass Shipment(BaseModel):\n packages: list[Package]\n\n\ndata = {\n \"packages\": [\n {\"tracking_id\": \"PKG-1\", \"weight_kg\": 2.5, \"dimensions\": {\"length\": 10, \"width\": 10, \"height\": 10}},\n {\"tracking_id\": \"PKG-2\", \"weight_kg\": \"bad\", \"dimensions\": {\"length\": 20, \"width\": 15, \"height\": 10}},\n ]\n}\n\ntry:\n shipment = Shipment.model_validate(data)\nexcept ValidationError as e:\n print(e)\n```",[],[],"d1385c01-9f96-481c-9973-1ad41bceeabb",690,"6e5a90a7-3668","3.4 - Alternative Types and Runtime Checks","When would this not work?\n\nWhen we’re not following a strict inheritance hierarchy, it doesn’t make sense to force a parent type.\n\nFor example, it’s pretty common to see dictionaries used as an alternative to a custom type. Especially for people coming from JavaScript who are used to creating objects on the fly.\n\nWe have to narrow the type inside (with `isinstance`) as we can’t treat these two separate types the same.\n\n```python\nclass Student:\n def __init__(self, name: str, age: int) -> None:\n self.name = name\n self.age = age\n\n\ndef print_all(data: Student | dict) -> None:\n items = data if isinstance(data, dict) else data.__dict__\n\n for key, value in items.items():\n print(f\"{key}: {value}\")\n\n\nalice = Student(\"Alice\", 20)\nbob = {\"name\": \"Bob\", \"age\": 22, \"major\": \"CS\"}\n\nprint_all(alice)\n# name: Alice\n# age: 20\n\nprint_all(bob)\n# name: Bob\n# age: 22\n# major: CS\n```\n\nAnd in general forcing inheritance hierarchies can make things sloppy so i generally prefer protocols.\n\n> [!tip]\n> This is in contrast to overloading in other programming languages. In Python we have just one function with potentially multiple branches for various types. Compare this to something like C# which would have variations of the function defined by the parameter type and count.\n> However, Python does have `singledispatch` and `singledispatchmethod`.\n>\n> [functools - Higher-order functions and operations on callable objects](https://docs.python.org/3/library/functools.html#functools.singledispatch)\n>\n> Which allows us to overload functions defining separate bodies for different types.\n>\n> ```text\n> @fun.register\n> def_(arg: int, verbose=False):\n> \t...\n>\n> @fun.register\n> def_(arg: list, verbose=False):\n> \t...\n> ```\n\n## Now, named tuples\n\nAnother type you may see is a named tuple, which works like a regular tuple but the spots are named.\n\n```python\n\nfrom abc import ABC, abstractmethod\nfrom typing import NamedTuple\n\nclass StudentTuple(NamedTuple):\n name: str\n age: int\n\n\ndef process(person: Person | dict | StudentTuple) -> None:\n if isinstance(person, Person):\n items = person.__dict__\n elif isinstance(person, dict):\n items = person\n elif isinstance(person, StudentTuple):\n items = person._asdict()\n else:\n raise TypeError(\"expected person\")\n\n for key, value in items.items():\n print(key, value)\n\n\nprocess(Teacher(\"Caleb\", 50, \"compsci\"))\nprocess(Student(\"John\", 54, 3.5))\nprocess({\"name\": \"Caleb\"})\nprocess(StudentTuple(\"Caleb Tuple\", 85))\n\n## Data class\n```\n\nThis technically works, but is not the most ideal use case of a named tuple. I wanted to show this to see that you can expand the allowed types in the type hinting and you could receive “objects” in various forms beyond a proper instantiated Student.\nTypically, tuples are ideal for things that are just values with minimal behavior such as a point or color pick.\n\n```python\n# coordinates - a point is a point, you don't mutate it\nclass Point(NamedTuple):\n x: float\n y: float\n\norigin = Point(0, 0)\n# origin.x = 5 # TypeError\n\n\n# RGB color - (255, 128, 0) is always that color\nclass Color(NamedTuple):\n r: int\n g: int\n b: int\n\norange = Color(255, 128, 0)\n```\n\n## Dataclasses\n\nAnother type of class you may see is a `dataclass` (I’d default to choosing this over a named tuple personally). This is probably the preferred approach over named tuples. This creates a standard class and is not something different like a tuple or dictionary, but it gives you some boilerplate implementations. You may see this with data-heavy classes that are less about operations.\n\n```python\nfrom dataclasses import dataclass\n\n@dataclass\nclass Course:\n name: str\n instructor: str\n credits: int\n\n\nprint(Course(\"math\", \"Caleb\", 4)) # generated for you\n\nprint(Course(\"math\", \"Caleb\", 4) == Course(\"math\", \"Caleb\", 4)) #generated for you by value\n\nprint(type(Course(\"math\", \"Caleb\", 4))) #regular class\n\n```\n\nAs you can tell, there are a million ways to do things. I tend not to use specialized types unless there is a strong reason to.\n\nThere are EXTENSIVE docs on type hinting. This will get you most of the way there, but you can read through the details if you want to know everything.",[],[],"92159d55-4eda-45be-b394-795692caa0b9",695,"942745ca-a729","3.3 - Abstract Base Classes","Real quick let’s look back at enums. These are real types that are accessible at runtime:\n\n```python\norder = SortOrder.DESC\nprint(type(order))\n\nif isinstance(order, SortOrder):\n print(\"Valid value\")\n```\n\nThe equivalent idea exists with Classes. Earlier we would do something like `Teacher | Student`, which is type hinting but doesn’t give us validation capabilities at runtime. Here is without a runtime check:\n\n```python\nclass Teacher:\n def teach(self) -> None: ...\n\nclass Student:\n def study(self) -> None: ...\n\ndef process(person: Teacher | Student) -> None:\n print(person) \n```\n\nWe can do a runtime check with classes:\n\n```python\ndef process(person: Teacher | Student) -> None:\n if not isinstance(person, (Teacher, Student)):\n raise TypeError(f\"Expected Teacher or Student, got {type(person)}\")\n```\n\nHowever an abstract base class allows us to capture what is shared across teacher and student in a similar way to Protocols (see earlier lesson), but at runtime.\n\n```python\ndef process(person: Person) -> None: \n\tif not isinstance(person, Person): \n\t\traise TypeError(f\"Expected Person, got {type(person)}\")\n```\n\n## Polymorphism\n\nInstead of doing `Teacher | Student` for static typing we can use an abstract base class. This will eventually allow us to do a runtime check:\n\n```python\n\nclass Person(ABC):\n def __init__(self, name: str, age: int) -> None:\n self.name = name\n self.age = age\n\n @abstractmethod\n def role(self) -> str: ...\n\n def introduce(self) -> str:\n return f\"I'm {self.name}, a {self.role()}\"\n\n\nclass Teacher(Person):\n def __init__(self, name: str, age: int, department: str) -> None:\n super().__init__(name, age)\n self.department = department\n\n def role(self) -> str:\n return \"teacher\"\n\n\nclass Student(Person):\n def __init__(self, name: str, age: int, gpa: float) -> None:\n super().__init__(name, age)\n self.gpa = gpa\n\n def role(self) -> str:\n return \"student\"\n\n\ndef process(person: Person) -> None:\n if not isinstance(person, Person):\n raise TypeError(\"expected person\")\n print(person.introduce())\n\nprocess(Teacher(\"Caleb\", 50, \"compsci\"))\nprocess(Student(\"John\", 54, 3.5))\n```",[],[],"5c85a5d5-828e-47f6-9ffc-685cc10e868a",634,"6182b837-6828","3.2 - Types for Functions","## Callables\n\n[Callables - typing documentation](https://typing.python.org/en/latest/spec/callables.html#callable)\n\n```python\nCallable[[Param1Type, Param2Type], ReturnType]\n```\n\nHere is an example of a higher order function (takes a function as an argument). The function passed in is expected to have two parameters of type int and return a float.\n\nWe then use this function by creating another function `divide`.\n\n```python\nfrom typing import Callable\n\n\ndef apply(func: Callable[[int, int], float], a: int, b: int) -> float:\n return func(a, b)\n\n\ndef divide(a: int, b: int) -> float:\n return a / b\n\n\napply(divide, 10, 3)\n```\n\nOr for arguments you’ll often see lambda functions. This creates a function that takes `a` and `b` and does `a / b` .\n\n```python\napply(lambda a, b: a / b, 10, 3)\n```\n\n## Any\n\nThis is a pretty common thing to see to explicitly state something can be of any type, ignoring any type checking you would have otherwise encountered.\n\n```python\nfrom typing import Any\n\n# opts out of type checking entirely\ndef log(value: Any) -> None:\n print(value)\n```\n\n## TypedDict\n\nStill a dict at runtime.\n\n```python\nfrom typing import TypedDict\n\nclass UserData(TypedDict):\n name: str\n age: int\n email: str\n\ndef process(user: UserData) -> None:\n print(user[\"name\"]) # type checker knows this is str\n\n# it's still a plain dict at runtime\nuser: UserData = {\"name\": \"Alice\", \"age\": 20, \"email\": \"alice@test.com\"}\n```\n\n## Enum\n\nLet’s also talk about Types that do make a difference at runtime and not just hints for static typing. Such as Enum.\n\nEnum is different than a union as it says the value is one of multiple predefined constants. They’re all of the same type, so it is used to restrict to a set of values. Union can be different types.\n\nIf you want to restrict to certain values statically, you can use Literal.\n\n```python\ndef set_role(role: Literal[\"student\", \"teacher\"]) -> str: ...\n```\n\nBut this doesn’t enforce anything at runtime, while an enum does.\n\nSo I would use Literal if we are working with something like a string type but you want to restrict it statically to some possible values without requiring the use of an enum throughout the code.\n\nA simple example of this would be:\n\n```python\nsort(numbers, \"asc\")\n```\n\nWe could define this function like so:\n\n```python\nfrom typing import Literal\n\n\ndef sort(items: list[int], order: Literal[\"asc\", \"desc\"] = \"asc\") -> list[int]:\n return sorted(items, reverse=(order == \"desc\"))\n\n\nnumbers = [3, 1, 4, 1, 5]\n\nprint(sort(numbers, \"asc\")) # [1, 1, 3, 4, 5]\nprint(sort(numbers, \"desc\")) # [5, 4, 3, 1, 1]\n```\n\nCompare this to an enum which is an actual type.\n\n```python\nfrom enum import Enum\n\n\nclass SortOrder(Enum):\n ASC = \"asc\"\n DESC = \"desc\"\n\n\ndef sort(items: list[int], order: SortOrder = SortOrder.ASC) -> list[int]:\n return sorted(items, reverse=(order == SortOrder.DESC))\n\n\nnumbers = [3, 1, 4, 1, 5]\n\nprint(sort(numbers, SortOrder.ASC)) # [1, 1, 3, 4, 5]\nprint(sort(numbers, SortOrder.DESC)) # [5, 4, 3, 1, 1]\n```\n\nOur full code:\n\n```python\ndef apply(func: Callable[[int, int], float], a: int, b: int) -> float:\n return func(a, b)\n\n\ndef divide(a: int, b: int) -> float:\n return a / b\n\n\n# print(apply(divide, 5, 2))\nprint(apply(lambda a, b: a / b, 10, 5))\n\n## Any\n\n\ndef log(value: Any) -> None:\n print(value)\n\n\n## Typed Dictionary TypedDict\n\n\nclass UserData(TypedDict):\n name: str\n age: int\n email: str\n\n\ndef process(data: UserData):\n print(data[\"name\"])\n\n\ndata: UserData = {\"name\": \"caleb\", \"age\": 980, \"email\": \"caleb@calebcurry.com\"}\n\nprocess(data)\n\n## Enums\n\n\nclass SortOrder(Enum):\n ASC = \"asc\"\n DESC = \"desc\"\n\n\ndef sort(items, order: SortOrder = SortOrder.ASC):\n return sorted(items, reverse=(order == \"desc\"))\n\n\nnumbers = [34, 65, 23, 87, 34, 234, 76]\n\nprint(sort(numbers, SortOrder.DESC))\n\n```",[],[],"06db6b36-bf7c-4a8e-a799-3a1cd2f55819",609,"e83d0481-783f","3.1 - Iterators and Generators","Quick overview of an iterator vs an iterable.\n\nAn iterator is something we can loop through. It invokes `__iter__` on the object which gives us an iterator. In this case, the iterable is the object.\n\nThe iterator returned allows us to lazily grab one element at a time. It maintains the state of where you are in the consumption of the collection.\n\n[06. Iterable, Iterator, Generator - Python Notebook from Zero to Advanced](https://zhenyuanlu.com/python-notebook/06_iterable_iterator_generator)\n\n```python\ndata = [1, 5, 9] # iterable\n\nit = iter(data) # iterator\n\nprint(next(it)) # lazy retrieval\nprint(next(it)) # lazy retrieval\nprint(next(it)) # lazy retrieval\n\n```\n\nEasiest way to create an iterator:\n\n```python\n# a generator that yields items instead of returning a list\ndef firstn(n):\n num = 0\n while num < n:\n yield num\n num += 1\n\nsum_of_first_n = sum(firstn(1000000))\n```\n\n```python\nfrom typing import Iterable\nfrom itertools import chain\n\ndata = [1, 5, 9] # iterable\n\nit = iter(data) # iterator\n\nprint(next(it)) # lazy retrieval\nprint(next(it)) # lazy retrieval\nprint(next(it)) # lazy retrieval\n\n\ndef firstn(n):\n num = 0\n while num < n:\n yield num\n num += 1\n\n\ndata = firstn(100)\nprint(data)\n\nprint(next(data))\nprint(next(data))\nprint(next(data))\nprint(next(data))\nprint(list(data)) # starts at 4\n\nfor i in firstn(10): # we have to use a new generator object\n print(i)\n\nprint(sum((x**2 for x in firstn(10))))\n\n\ndef print_all(data: Iterable[int | str]) -> None:\n for d in data:\n print(d, end=\"\")\n print()\n\n\nprint_all(firstn(4))\nprint_all(\"Caleb\")\n\nfirst = \"Caleb\"\nlast = \"Curry\"\n\nname = chain(first, \" \", last)\nprint_all(name)\n```\n\nThere are also other types you may find.\n\n```python\nfrom typing import Dict, List, Set, Tuple, FrozenSet\n```\n\nVariety of types made available for whatever you might be building.\n\nAlso worth noting that we can create a generator expression similar to a list comprehension but surrounded with `()`.\n\n```python\nprint(sum((x**2 for x in firstn(10))))\n```\n\nThis CAN be used to generate a full list, but could also be used one element at a time such as for building a sum. You may see this also for consuming large amounts of data in a streaming fashion, something like this:\n\n```python\nlines = (line.strip() for line in open(\"huge_file.txt\"))\nfor line in lines:\n process(line)\n```",[],[],"00575e88-35e6-4912-a20b-54b5110d1569",741,"8e5c0ff0-d315-4161-9cb7-81be1bd7c10e","Section 2 - Type Safety",[725,726,727,728,729],{"_63":758,"_65":759,"_67":68,"_439":127,"_441":18,"_452":760,"_453":722,"_454":761,"_456":762,"_458":-5,"_459":763,"_461":764,"_463":464,"_465":466,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":751,"_65":752,"_67":68,"_439":490,"_441":18,"_452":753,"_453":722,"_454":754,"_456":755,"_458":-5,"_459":756,"_461":757,"_463":464,"_465":466,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":744,"_65":745,"_67":68,"_439":482,"_441":18,"_452":746,"_453":722,"_454":747,"_456":748,"_458":-5,"_459":749,"_461":750,"_463":464,"_465":466,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":737,"_65":738,"_67":68,"_439":474,"_441":18,"_452":739,"_453":722,"_454":740,"_456":741,"_458":-5,"_459":742,"_461":743,"_463":464,"_465":466,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":730,"_65":731,"_67":68,"_439":451,"_441":18,"_452":732,"_453":722,"_454":733,"_456":734,"_458":-5,"_459":735,"_461":736,"_463":464,"_465":466,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},"18856e59-0ba4-43f5-9e99-cca39d63a328","2.5 - Requiring Methods","Another example here requires the object to have the `items` method:\n\n```python\nclass SupportsItems(Protocol):\n def items(self) -> ...: ...\n\n\ndef print_data[T: SupportsItems](data: T) -> T:\n for key, value in data.items():\n print(key, value)\n return data\n```\n\nNote that using `[T: SupportsItems]` after the function name is only required if you’re matching T in the return. You could just have this:\n\n```python\ndef print_data(data: SupportsItems) -> None:\n for key, value in data.items():\n print(key, value)\n```\n\nThis new `print_data` function will work with dictionaries, and our custom type if we implement that method.\n\n```python\nstudents: list[Student] = []\nstudents.append(Student(\"Caleb Curry\", 95, Address(\"hello\", \"this\", \"is a test\")))\nstudents.append(Student(\"Kale\", 97, Address(\"hello\", \"this\", \"is a test\")))\n\nstudent = {\"name\": \"Paul\", \"age\": 30, \"Address\": None}\nprint_data(student)\nprint_data(students[0])\n\n```\n\nAnd back in our Student class:\n\n```python\nclass Student:\n def __init__(self, name: str, age: int, address: Address | None) -> None:\n self.name = name\n self.age = age\n self.address = address\n\n def items(self):\n return self.__dict__.items()\n```\n\nThis follows a common design pattern of getting rid of unneeded inheritance and describing needed behavior in protocols (interfaces, contracts).\n\nCan learn more about similar ideas in [dependency inversion](https://en.wikipedia.org/wiki/Dependency_inversion_principle) and [composition over inheritance](https://en.wikipedia.org/wiki/Composition_over_inheritance).\n\nWe can also be more specific on the implementation requirements. Here we define the return type. We can use `dict_items` (what is returned when you invoke `.items`) or an abstract base type such as `ItemsView`.\n\n```python\nclass SupportsItems(Protocol):\n # def items(self) -> dict_items[str, Any]: ...\n def items(self) -> ItemsView[str, Any]: ...\n\n```\n\nEquivalent idea of of a `list` and `sequence`.\n\nI don’t find Python docs very intuitive, but here are a bunch of links I pieced together.\n\nHere is the definition of dictionary view:\n\n[Glossary](https://docs.python.org/3/glossary.html#term-dictionary-view)\n\nYou can see an overwhelming number of types here:\n\n[Built-in Types](https://docs.python.org/3/library/stdtypes.html)\n\nDict: [Built-in Types](https://docs.python.org/3/library/stdtypes.html#dict)\n\n[collections - Container datatypes](https://docs.python.org/3/library/collections.html)\n\nUnderlying abstract base classes: [collections.abc - Abstract Base Classes for Containers](https://docs.python.org/3/library/collections.abc.html#)\n\nWe still have a lot to cover with types including data validation at runtime. We’ll continue in the next section!",[],[],"3b029770-cb2c-4438-9623-7a5284bed299",532,"f3612d73-54e7-4abb-9fe3-ba04fc51e7f0","2.4 - Generics and Protocols","For this we will want to type any variables that may not be able to infer types:\n\n```python\n\nstudents: list[Student] = []\n```\n\nYou’ll see `TypeVar` but you’ll also see a newer syntax (3.12+) that defines the Type in the function definition.\n\n[Advanced type annotations using Python's TypeVar - Piccolo Blog](https://piccolo-orm.com/blog/advanced-type-annotations-using-python-s-type-var/)\n\n> The argument to `TypeVar()` must be a string equal to the variable name to which it is assigned. Type variables must not be redefined.\n> [Generics - typing documentation](https://typing.python.org/en/latest/spec/generics.html)\n\nBenefits:\n\n- Code reuse\n- Match parameter with return type\n\t- Consider the case we wanted to pass in a list of students and get back a student or pass in a list of teachers and get back a teacher.\n\nYou may think to do this:\n\n```python\ndef get_oldest(data: list[Student | Teacher]) -> Student | Teacher | None:\n if not data:\n return None\n return max(data, key=lambda d: d.age)\n```\n\nThe problem is that we have a disconnect between the arguments and parameters. We may want to always return the same type as what is passed in, but can’t easily enforce that requirement here. You could pass in a teacher and have a student returned.\n\n```python\ndef get_oldest[T](data: list[T]) -> T | None:\n if not data:\n return None\n return max(data, key=lambda d: d.age) \n```\n\nThis will make sure that all `T`s end up being the same type.\n\nHowever, it doesn’t know if `T` has `.age`. We can fix this with a protocol.\n\n## Protocols\n\nProtocols in Python are the equivalent to interfaces in other languages, or traits. Basically, instead of having a rigid inheritance hierarchy you can define protocols to instead describe behaviors that must be met by certain types.\n\n```python\nclass HasAge(Protocol):\n age: int\n\n\ndef get_oldest[T: HasAge](data: list[T]) -> T | None:\n if not data:\n return None\n return max(data, key=lambda d: d.age)\n```",[],[],"0a1f8512-76bb-474b-8b4d-f79b50bc0ed2",538,"82edb9a5-0166-47f8-9725-d7849e7f86e1","2.3 - Type Safety","First thing to know is that Python is dynamically typed. Types are not considered for a program to be valid (like a compiled program would check at compile time) and the data type that a variable can hold can change during execution.\n\nWe don’t have different signatures with different parameter types for functions, it’s just one function.\n\n## Type Annotations\n\nWe can specify types of things IF WE WISH. However this is more for our sake than for Python. The execution itself remains the same.\n\n> The Python runtime does not enforce function and variable type annotations. They can be used by third party tools such as [type checkers](https://docs.python.org/3/glossary.html#term-static-type-checker), IDEs, linters, etc.\n>\n> [typing - Support for type hints](https://docs.python.org/3/library/typing.html)\n\n```python\nx: int = \"hello\" \nprint(x) \n```\n\nThis can still run fine.\n\nYes, you may see errors in the Problems tab, but those are from Pylance, not from Python itself. Pylance is using our type annotation to help us write better code, but it’s not enforced when you execute with Python.\n\nHere is a good reference from mypy but still generally useful. [Type hints cheat sheet - mypy 1.19.1 documentation](https://mypy.readthedocs.io/en/stable/cheat_sheet_py3.html)\n\n> [!tip]\n> Older versions may have you import from typing but not required now, however you may still need it for advanced type hints.\n\nWe can also do this for functions, helping us to not call a function with the incorrect data.\n\n```python\ndef log(message: str) -> None:\n print(message)\n```\n\nAlso here:\n\n> A **statically typed** programming language runs a type checker before running a program. The program is required to be well typed according to the language’s type system. The type system assigns a type to all expressions in the language and verifies that their uses obey the typing rules. Normally, a program that is not well typed (i.e., one that contains a type error) will not run. Java and C++ are examples of statically typed object-oriented languages.\n> A **dynamically typed** programming language does not run a type checker before running a program. Instead, it checks the types of values before performing operations on them at runtime. This is not to say that the language is “untyped”. Values at runtime have a type and their uses obey typing rules. Not every operation will be checked, but certain primitive operations in the language such as attribute access or arithmetic are. Python is a dynamically typed language.\n> **Gradual typing** is a way to combine static and dynamic typing. Type-annotated Python allows opting in to static type checking at a fine level of granularity, so that some type errors can be caught statically, without running the program. Variables, parameters, and returns can optionally be given static type annotations. Even within the type of a single data structure, static type checking is optional and granular. For example, a dictionary can be annotated to enable static checking of the key type but only have dynamic runtime checking of the value type.\n>\n> [Type system concepts - typing documentation](https://typing.python.org/en/latest/spec/concepts.html)\n\nTyping is incremental in that you don’t have to type everything in your files but can start adding it where it gives you the most benefit.\n\nYou can use `any` any time you want to explicitly state the type of something should be ignored until runtime.\n\n## Type Hinting Example\n\n```python\nclass Address:\n def __init__(self, street: str, city: str, state: str) -> None:\n self.street = street\n self.city = city\n self.state = state\n\n\nclass Student:\n def __init__(self, name: str, age: int, address: Address) -> None:\n self.name = name\n self.age = age\n self.address = address\n\n\ndef get_city(student: Student) -> str:\n return student.address.city\n\n\ndef oldest(students: list[Student]) -> Student | None:\n if not students:\n return None\n return max(students, key=lambda s: s.age)\n```\n\n## Union, Optional\n\nUnion allows us to specify one of a few options for type checking.\n\nThese are the old school way of doing things. Very good chance you’ll see them in the wild, don’t think of them as something else just remember they’ve been replaced with `|`.\n\n```python\nfrom typing import Union\n\nclass Student:\n def __init__(self, name: str, age: int, address: Union[Address, None]) -> None:\n self.name = name\n self.age = age\n self.address = address\n```\n\nAnd Optional is just a shorthand for Union with None:\n\n```python\nfrom typing import Optional\n\nclass Student:\n def __init__(self, name: str, age: int, address: Optional[Address]) -> None:\n```\n\n## Working with None\n\nTLDR it’s a pain but necessary.\n\nWhen we mark an address as possibly None, we have to always consider that case.\n\nSo `get_city` must now check if address is None before accessing data, and we will do the same when working with students.\n\nI’ve also shared 4 different approaches to working with None:\n\n1. Check for None before accessing\n2. Conditional expression\n3. Assignment expression\n4. Try except\n\n```python\nclass Address:\n def __init__(self, street: str, city: str, state: str) -> None:\n self.street = street\n self.city = city\n self.state = state\n\n\nclass Student:\n def __init__(self, name: str, age: int, address: Address | None) -> None:\n self.name = name\n self.age = age\n self.address = address\n\n\ndef get_city(student: Student) -> str | None:\n if student.address:\n return student.address.city\n return None\n\n\ndef get_oldest(students: list[Student]) -> Student | None:\n if not students:\n return None\n return max(students, key=lambda student: student.age)\n\n\nstudents = []\n# students.append(Student(\"Caleb Curry\", 95, Address(\"hello\", \"this\", \"is a test\")))\n# students.append(Student(\"Kale\", 97, Address(\"hello\", \"this\", \"is a test\")))\n\n# Call function then check return\nstudent = get_oldest(students)\nif student:\n print(student.name)\n\n# Conditional Expression (Ternary)\n# Value or some default\nname = student.name if student else \"Unknown\"\nprint(name)\n\n# Walrus Operator\n# Assignment Expression\nif student := get_oldest(students):\n print(student.name)\n\n# Try Except\n# Bascically optional chaining equivalent\nstudent = None\ntry:\n student = get_oldest(students)\n print(student.address.city) # type: ignore\nexcept AttributeError:\n # Keep print commented out to fail silently and just go with None\n pass\n # print(\"Error accessing data\")\n\nprint(student)\n\n```\n\nThis is all in effort to avoid runtime `AttributeError` which is basically Python’s equivalent of a null pointer exception.\n\nThe final section you may notice that it could catch multiple levels of None. student could be None or address could be None. This was by design. I’m condensing all the None checking in to a single block which will give me None if anything in that chain is None.\n\nI’m basically mocking this behavior - [Optional chaining (?.) - JavaScript | MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Optional_chaining)",[],[],"0169e055-4a4a-44ac-b435-da6928ae9540",1179,"99770e9c-918c-4fae-a0b9-571a9d3413b6","2.2 - Installing and Creating Wheels","Packages are distributed as either source code or as a wheel.\n\nWheels are compiled for your version of Python and platform (operating system and CPU architecture). The wheels can make things faster and smoother but if a wheel doesn’t exist for your platform you will have to go from source, potentially requiring additional compilers.\n\n[ELI5 Python wheels](https://www.reddit.com/r/learnpython/comments/78xtap/eli5_python_wheels/)\n\nYou can easily create a wheel for a project with `uv`. We don’t need to do this right now, I am mainly showing for demonstration purposes how wheels can be generated.\n\n```python\nuv build\n```\n\nThis should generate a `dist` folder with a `.tar.gz` and a `.whl`.\n\nThis may also generate a folder about an egg. This is the old school way of packaging. You can remove that and update your `pyproject.toml`:\n\n```python\n[tool.hatch.build.targets.wheel]\npackages = [\"python-mastery\"]\n\n[build-system]\nrequires = [\"hatchling\"]\nbuild-backend = \"hatchling.build\"\n```\n\n[Why Hatch? - Hatch](https://hatch.pypa.io/latest/why/)\n\nHatch is a build system that is often recommended over the default [setuptools](https://github.com/pypa/setuptools) you may run in to.\n\nCheck out [scikit-learn](https://pypi.org/project/scikit-learn/) for example and visit the Download Files section.\n\nPyPI is Python Package Index and is the default source for installing packages with uv / pip.\n\nYou’ll see the source (as a tar.gz) and then a million wheels.\n\n![](https://course-catalyst-pull-zone.b-cdn.net/photos/NWRjZDgzMDct/lesson-migration/2026/07/ybKrAUJe8CGj.png)\n\n## Why Python Version is so Important\n\n```python\nuv add scikit-learn\nResolved 6 packages in 7ms\nBuilt numpy==2.4.2 × Failed to build scipy==1.17.0\n├─▶ The build backend returned an error\n╰─▶ Call to mesonpy.build_wheel failed (exit status: 1)\n```\n\n```python\nuv run python --version\n```\n\nGives us Python 3.15.0a6\n\nBut at the time of this writing there isn’t a wheel for this, so our system tries to build it and fails for whatever reason, if it will even work on Python 15. You can fix the reason or you can use a Python version that does have a wheel.\n\n> [!tip]\n> For mainstream packages if a wheel doesn’t exist for your platform there is a good chance it is not easily supported. You could get it working, but you may want to adjust your platform if you’re not using something very common (either Python version, OS, or architecture).\n\n```python\nuv python pin 3.14\nUpdated `.python-version` from `3.15` -> `3.14`\ncaleb@Calebs-MacBook-Air python-mastery % uv add scikit-learn \nUsing CPython 3.14.3\nRemoved virtual environment at: .venv\nCreating virtual environment at: .venv\nResolved 6 packages in 6ms\nPrepared 3 packages in 1.15s\nInstalled 5 packages in 58ms\n + joblib==1.5.3\n + numpy==2.4.2\n + scikit-learn==1.8.0\n + scipy==1.17.0\n + threadpoolctl==3.6.0\n```\n\nNow it installed perfectly.\n\nUsually grabbing the wheel is fine. I think there are various scenarios where grabbing source directly could be preferred (even if a wheel exists for you), such as if there are some compile-time options for the library. I’ll show an example for demonstration, but not something you’re going to be doing on the daily:\n\n```python\nuv sync --no-binary \n```",[],[],"5bacd6de-2886-4bdc-b86f-b1591441eadc",640,"82a7ad66-4944-4236-97cb-8487d1feb14d","2.1 - Dependencies, Wheels, and Deploying Python","## Environment Tooling vs Dev tools vs Dependencies\n\nDev dependencies are used in development but are not actual libraries used. Pylance, for example.\n\nThese would be good to document in your project readme so everyone is on the same page, but are not always strictly required.\n\nThen we have dev dependencies, these are installed locally but not on a deployed environment.\n\nThis ensures all devs get the same version, but reduces what is required to be installed on the server. This could include libraries for software testing, for example.\n\n> [!tip]\n> What if you want to run tests on the server before deploying? This is usually done in a CICD pipeline and would be a separate step. So, the end server still doesn’t get the testing lib.\n> We’d basically have a dedicated runner to run the tests and either pass or fail.\n\nYou can avoid installing dev dependencies on deployed environments usually with a flag or modification in the deployment script.\n\n> - Remove `dev` from `default-groups`, so `dev` dependencies always need to be enabled explicitly (`uv run --group dev`).\n> - Pass `-no-sync` to `uv run` (`uv run --no-sync`) so that `uv run` doesn't install new dependencies.\n>\n> [Even with `uv sync --no-dev`, development dependencies are still installed when workflow executes. · Issue #12558 · astral-sh/uv](https://github.com/astral-sh/uv/issues/12558#issuecomment-2764611918)\n\nFinally, we have true dependencies. These are libraries the server actually needs to run.\nDo we put the virtual environment on the end server? You *can* but usually not, as you should think of the actual files as replaceable. All the server needs is the list, and when you deploy it will retrieve those packages.\n\n## What is a lock file?\n\nPretty universal concept (see also `package.json` for Node, or `Cargo.lock` in Rust).\n\nIn your dependencies you may have\n\n```python\ndependencies = [\n \"requests>=2.30\",\n]\n```\n\nbut this doesn’t say EXACTLY what version, so when you install from this you’ll get an exact version and that is what is put in the lock file. This is more precise for future installs.\n\nDoes the lock file go in source control? Yep, that makes sure everyone gets the exact same libs.\n\ndoes it get deployed? Yep. Package manager will install from the lock file list to get exact versions.\n\n## Missing a Lock File?\n\nWhat if it is missing? It will generate a new one when you install from the regular dependencies file. This could introduce minor issues, if a different version is picked up compared to earlier before.\n\nWhen you’re learning development, this is not a huge issues usually, but when you’re deploying software it can be a problem because we want to make sure we don’t have code that doesn’t work correctly with the associated libraries.\n\nESPECIALLY so for an interpreted language that may not catch changes as easily, such as identifier changes in the library (interface to use the library changes). Say for example, a function you are using is deprecated and removed.\n\nThere could also be behavioral changes that would mess up even in a compiled language because the interface stays the same, such as a returning an incorrect value but still of the same type. Introduced bugs in the library could go unnoticed.\n\n## Options for Deploying\n\nTo run your python program on a server, you’ll install the same dependencies on that machine as on your local. This is why it is nice to have the same OS or as close as possible to the destination. I develop on a Mac but will deploy to Linux, which is not the same obviously, so sometimes I run in to issues with incompatibilities.\n\nDocker will help fix this problem, but there are additional difficulties with working with Docker. If you want to invest the time to learn Docker it can help a lot.\n\n> [!tip]\n> With docker you can often skip a virtual environment as it functionally does the same thing (isolating env with needed deps).\n\nYou can also deploy through PyPI, creating a package users can install from there if they are expected to be working with pip / uv.\n\nFinally, you can create executables, pretty common for desktop software. Most of what I do is deploying to servers, such as building a web backend. But there does exist software to help build Python installers and executables where the end destination is a desktop computer (such as PyInstaller).\n\nI cannot tell you how many times this issue happened for people working through my content. They develop locally with Python, and deploy to AWS. Deployment fails. Gives some vague message of being unable to find some package.\n\nWell, it’s a windows specific package. So then they have do to do additional research on how to include it locally but not use it in the deployment, leads to complexity and “works on my machine” problem.",[],[],"2c5c8a92-8102-4ff1-8612-108d35cbf8d2",1008,"0dc0688f-bc88-479c-8ff0-b9c242f2347e","Section 1 - Environment Management",[768,769,770,771,772],{"_63":801,"_65":802,"_67":68,"_439":127,"_441":18,"_452":803,"_453":765,"_454":804,"_456":805,"_458":-5,"_459":806,"_461":807,"_463":464,"_465":466,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":794,"_65":795,"_67":68,"_439":490,"_441":18,"_452":796,"_453":765,"_454":797,"_456":798,"_458":-5,"_459":799,"_461":800,"_463":464,"_465":466,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":787,"_65":788,"_67":68,"_439":482,"_441":18,"_452":789,"_453":765,"_454":790,"_456":791,"_458":-5,"_459":792,"_461":793,"_463":464,"_465":466,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":780,"_65":781,"_67":68,"_439":474,"_441":18,"_452":782,"_453":765,"_454":783,"_456":784,"_458":-5,"_459":785,"_461":786,"_463":464,"_465":466,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":773,"_65":774,"_67":68,"_439":451,"_441":18,"_452":775,"_453":765,"_454":776,"_456":777,"_458":-5,"_459":778,"_461":779,"_463":464,"_465":466,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},"d2f3e7ec-8596-4308-8213-efca4b9b6c0c","1.5 - CPython and .pyc Files","In the previous section we talked about how we install packages for a project, but I want to talk now about what is happening behind the scenes.\n\nFirst off, you should understand that Python is an interpreted language, but it is partially compiled…compiled to **bytecode**.\n\nBecause of this compilation step, you can still get syntax errors.\n\n```python\npython3 1/example.py \n File \"/Users/caleb/cs/python-mastery/1/example.py\", line 10\n ]\n ^\nSyntaxError: unmatched ']'\n```\n\n> [!tip]\n> Note that this error comes from executing python, and I’m not relying on linting or errors showing up in Intellisense.\n\nHowever some things will be shifted to runtime errors that would be caught by a compiled language:\n\n```python\ndata = [1, 3, 4]\n\nprint(\"first\")\nprint(name)\n```\n\n```python\nfirst\nTraceback (most recent call last):\n File \"/Users/caleb/cs/python-mastery/1/example.py\", line 7, in \n print(name)\n ^^^^\nNameError: name 'name' is not defined\n```\n\nThis first prints the `first` and then has a runtime error.\n\n## Understanding .pyc files.\n\nThis compilation creates `.pyc` files, which are then ran.\n\nYou’ll often hear CPython, this is the standard Python implementation / interpreter.\n\nReading this reddit is highly recommended.\n\n[Understanding what CPython actually IS has greatly enhanced my understanding of Python.](https://www.reddit.com/r/learnpython/comments/1czzg57/understanding_what_cpython_actually_is_has/)\n\nI’ll leave the content here in case it ever gets deleted:\n\n## Understanding what CPython actually IS has greatly enhanced my understanding of Python.\n\nFirst off, its perfectly understandable to not really care about language theory as a beginner. This stuff is not necessary to learn to code.\n\nHowever, after recently doing some deep dives on what CPython really is and how it works, I have found the knowledge to be extremely enlightening. And it has really opened my eyes as to how Python is used, and why its used in the places it is.\n\nFor those who are unaware, allow me to share what I've learned.\n\nSo the key piece of information is that CPython is, at its core, a program written in C. Its purpose is to take Python code as input, then convert that Python into its own native instructions (written in C), and then execute them. And perhaps most importantly, it does this in a line-by-line manner. That just means it doesn't try to error check the entire program before running it. Potential errors just happen as it goes through each line of code, one by one.\n\nHowever its also important to understand that Python is actually still *semi-compiled* into \"bytecode\", which is an intermediate stage between Python and full machine code. CPython converts your python scripts into bytecode files first, so what it actually runs is the bytecode files.\n\nNow where it gets super interesting is that CPython is not the only \"implementation\" of Python (implementation means some kind of program, or system, that takes Python code as input and does something with it). More on that later.\n\nOn the subject of bytecode, it naturally leads to some other interesting questions, such as \"Can I share the bytecode files?\", to which the answer is no. That's one of the key aspects of CPython. The bytecode is \"not platform agnostic\". (I'm really sorry if that's not the correct term, I just learned all this stuff recently). That means the bytecode itself is compiled for your specific environment (the python version and dependencies). The reason for this is that its part of Python's design philosophy to be constantly improving the bytecode.\n\nOnce you understand that you can then comprehend what other implementations of Python do. PyPy for instance aims to make a Python running environment that works more like Java, where it performs \"just-in-time\" compilation to turn the bytecode into native machine code at runtime, and that's why it can make certain things run faster. Then you have the gamut of other ways Python can be used, such as:\n\n- Cython - aims to translate Python into C, which can then be compiled\n- Nuitka - aims to translate Python into C++, which is more versatile and less restrictive\n- Jython - this semi-compiles Python into Java bytecode that can be run in a Java virtual machine/runtime\n- IronPython - semi-compiles Python into C# bytecode, for running in .NET runtime\n- PyPy - A custom JIT-compiler that works in a manner philosophically similar to Java\n- MicroPython - a special version of python that's made for embedded systems and 'almost' bare-metal programming\n\nOh and then there's also the fact that if you want to use Python for scripting while working in other languages, its important to understand the difference between calling CPython directly, or using \"embedded\" CPython. For instance some game coders might opt to just call CPython as an external program. However some might opt to just build CPython directly into the game itself so that it does not need to. Different methods might be applicable to different uses.\n\nAnyway all of this shit has been very entertaining for me so hopefully someone out there finds this interesting.\n\nFrom this list you may want to be familiar with Cython, PyPy, and MicroPython. I don’t think we’ll end up using these in this course, but I don’t think it matters all that much. You may have to make changes in source code depending on the implementation of choice, but you’re still gonig to be writing Python. So unless you have a direct need for one of the other targets, I’d stick with CPython.\n\nThis explains sightings like MicroPython, which you’ll see is pretty popular for embedded systems.\n\n![](https://course-catalyst-pull-zone.b-cdn.net/photos/NWRjZDgzMDct/lesson-migration/2026/07/X4KyiEVmX_27.png)\n\n[Technology | 2025 Stack Overflow Developer Survey](https://survey.stackoverflow.co/2025/technology#most-popular-technologies-language)\n\n[MicroPython - Python for microcontrollers](https://micropython.org/)\n\n## CPython vs PyPy\n\nBoth come from the same source but CPython uses Just-in-time compiling, instead of just runtime interpretation.\n\n[Just-in-time compilation](https://en.wikipedia.org/wiki/Just-in-time_compilation)\n\nPyPy can be good for long running programs but are not ideal for quick running scripts. And may lag for Python features or libraries that are not supporting PyPy.\n\n[Why shouldn't I use PyPy over CPython if PyPy is 6.3 times faster?](https://stackoverflow.com/questions/18946662/why-shouldnt-i-use-pypy-over-cpython-if-pypy-is-6-3-times-faster)\n\nEven if it could runner faster there is no guarantee that your program would even be supported with PyPy (or any of the other implementations for that matter).\n\nYou can find these compiled files in your imported code in `/lib`.\n\nYou can think of these compiled files like a cache, by compiling the libs you can improve performance and they won’t need recompiled.\n\nYou can force it on all files but doesn’t really make sense since we’ll be changing these regularly.\n\n```python\npython3 -m compileall .\n```\n\nThese files are generated locally and therefore can be left out of version control.\n\nFor example.",[],[],"4b55c8d7-64a1-4dce-981c-d7ee4f39e7db",620,"cc3d29ad-8838-44b2-b833-d543a072f2d4","1.4 - Dependency Management with uv","You are likely familiar with `pip` and `venv`.\n\nIf you start going down the rabbit trail of environment management with Python you will be shocked by the number of options, confusing and conflicting advice, and multiple different approaches.\n\n[What is the difference between venv, pyvenv, pyenv, virtualenv, virtualenvwrapper, pipenv, etc?](https://stackoverflow.com/a/47559925)\n\nAfter reading this, I think I know less, not more!\n\n![](https://course-catalyst-pull-zone.b-cdn.net/photos/NWRjZDgzMDct/lesson-migration/2026/07/8knqg2c7nKFe.png)\n\nIt’s insane.\n\nI’d recommend one of two paths - Go with `venv`. This works if you’re already familiar with it. Or, bite the bullet and learn `UV`. Most people find it worth the investment.\n\n## High level overview of venv\n\n```python\npython -m venv .venv\n. .venv/bin/activate\npip install requests\npip freeze > requirements.txt\npip install -r requirements.txt\n```\n\nYou’re likely familiar with this from other lessons, but if not, these commands will get you 80% of the way there.\n\n## Package Management with UV\n\npip comes with Python, uv doesn't. But installation is pretty simple.\n\n[uv](https://docs.astral.sh/uv/)\n\nInstall with a command on this page:\n\n[Installation | uv](https://docs.astral.sh/uv/getting-started/installation/)\n\nI’ll use:\n\n```python\nbrew install uv\n```\n\nNow to recreate the pip experience we’ll first deactivate our venv and delete our `.venv` folder.\n\n```python\ndeactivate\n```\n\nok, now on to uv:\n\n```python\nuv init\nuv add requests\n# that's it\n```\n\nAnd then to install packages from a downloaded project:\n\n```python\nuv sync\n```\n\nThat’s the equivalent of:\n\n```python\npython -m venv .venv && . .venv/bin/activate && pip install -r requirements.txt\n```\n\n## Running the Program\n\nA `main.py` file was generated. We can run it like so:\n\n```python\nuv run python main.py\n```\n\n## Changing Python Version\n\nWhen we used `uv init` we got this `pyproject.toml` file:\n\n```python\n[project]\nname = \"python-mastery\"\nversion = \"0.1.0\"\ndescription = \"Add your description here\"\nreadme = \"README.md\"\nrequires-python = \">=3.13\"\ndependencies = []\n\n```\n\nWe can modify the Python version associated with this, which is a lot easier than\n\n```python\nuv python list\nuv python install 3.15\nuv python pin 3.15\n```\n\nYou’ll see in `.python-version`:\n\n```python\n3.15\n```\n\nThe `.python-version` is the actual python version you’re using, while the `pyproject.toml` `requires-python` is what is NEEDED for the project. You can adjust this value if you use a newer capability not supported in the listed version.",[],[],"5a425a0c-5880-40a8-8ed7-a81c4cbde82d",641,"3cb519a8-45c2-4eb8-b58e-aa41bb547d6f","1.3 - Code Formatting","[PEP 8 – Style Guide for Python Code | peps.python.org](https://peps.python.org/pep-0008/)\n\nThis document outlines the expected structure for your code, which you can you can do manually. Many times I do this, even in some of my tutorials I do a lot of the coding manually, but for speed and efficiency you can also use a formatter.\n\n[code.visualstudio.com](https://code.visualstudio.com/docs/python/formatting)\n\nThis will document the most common formatters for VS Code.\n\nWe’ll look at Ruff, but many people will still use autopep8 and black.\n\n[marketplace.visualstudio.com](https://marketplace.visualstudio.com/items?itemName=charliermarsh.ruff)\n\n> Ruff can be used to replace Flake8 (plus dozens of plugins), Black, isort, pyupgrade, and more, all while executing tens or hundreds of times faster than any individual tool.\n\nFor Ruff, we will install it and then set our user preferences in VS Code:\n\n```json\n \"[python]\": {\n \"editor.defaultFormatter\": \"charliermarsh.ruff\",\n \"editor.formatOnSave\": true,\n },\n```\n\nYou can test this by creating an array ending in a comma:\n\n```python\n\ndata = [1, 3, 4,]\n```\n\nOn save it should translate to:\n\n```python\ndata = [\n 1,\n 3,\n 4,\n]\n\n```\n\nAs typically ending in a comma implies an ongoing list and is often formatted in this nature.\n\n## Linting, Formatting and Deploying Software\n\nYou can add stages to the software deployment process that will actually check both of these things:\n\n1. Is the software meeting Pyright rules?\n2. Is the software following pep8 formatting?\n\nIf not, the deployment can fail and be kicked back to the developer to fix.\n\nThis is just a snippet, but the CICD might look like:\n\n```python\n- name: Check formatting\n run: ruff format --check .\n\n- name: Check linting\n run: ruff check .\n\n- name: Type checking\n run: pyright .\n\n- name: Tests\n run: pytest\n```\n\nIf interested in more of this you can look in to GitHub Actions.",[],[],"fae83784-c224-4ac4-b573-ed41389cc907",317,"891bb819-ddec-4cda-aa5c-0de2028af91e","1.2 - Type Checking and Linting","Let’s first work on the editor. Two worth mentioning here, and there are many more I am sure of it. Pycharm and VS Code.\n\nMany people will develop with Pycharm - [PyCharm: The only Python IDE you need](https://www.jetbrains.com/pycharm/)\n\nAnd you may benefit from it, but I already have established myself in the VS Code ecosystem, which is a more general purpose code editor.\n\n[code.visualstudio.com](https://code.visualstudio.com/)\n\n## Static Type Checking\n\nWithin VS code we will use Pylance - [marketplace.visualstudio.com](https://marketplace.visualstudio.com/items?itemName=ms-python.vscode-pylance)\n\nPylance is the extension, but behind the scenes it uses Pyright - [https://github.com/microsoft/pyright](https://github.com/microsoft/pyright)\n\n> Pylance has the ability to supercharge your Python IntelliSense experience with rich type information, helping you write better code faster.\n> Pylance provides some awesome features for Python 3, including:\n> - Docstrings\n> - Signature help, with type information\n> - Parameter suggestions\n> - Code completion\n> - Auto-imports (as well as add and remove import code actions)\n> - As-you-type reporting of code errors and warnings (diagnostics)\n> - Code outline\n> - Code navigation\n> - Type checking mode\n> - Native multi-root workspace support\n> - IntelliCode compatibility\n> - Jupyter Notebooks compatibility\n> - Semantic highlighting\n\nThere are alternatives to Pyright such as Mypy - [mypy - Optional Static Typing for Python](https://mypy-lang.org/)\n\nThese are known as static type checkers as they’ll look at the types of the data before code execution, helping you reduce runtime bugs. I’m naturally going to go for Pyright as I’ll have static checking through the Pylance Extension.\n\n## File Structure and Quick Example\n\nWe will also use Git as needed. I’ll start with a single repo for all of the code we cover in this course.\n\nThe repo: [https://github.com/CalebCurry/python-mastery](https://github.com/CalebCurry/python-mastery)\n\nLet’s create a directory with a folder `1` in it. Here we can create `example.py`.\n\n![](https://course-catalyst-pull-zone.b-cdn.net/photos/NWRjZDgzMDct/lesson-migration/2026/07/EZM48WSH2VKn.png)\n\nOr you can try to have an import that is not being used.",[],[],"65d9c6cf-adf1-4fd8-82d4-dcaa5a32e432",337,"d51b2545-22ae-4998-bc01-573c06f0713a","1.1 - Introduction","> [!tip]\n> Always remember to reference these notes as you watch the videos.\n> Any links are important to glance through or read through if you need additional understanding.\n\nWelcome to your 8 week Python Mastery bootcamp. We’ll cover a lot.\n\nThis first section is really designed to get a better understanding of your working environment, the tools at your service to help you be a better Python developer, as well as information to get a better understanding of how Python truly works behind the scenes.\n\n## What you should know going in to this\n\nYou should definitely understand everything we talked about in my two programming fundamentals sections. These use Python, so you’ll already become pretty familiar with the language, but focusing on general programming concepts. You’ll also get some experience seeing how a small project comes together at the end where we work with a database.\n\nThose sections should get you a level of proficiency in Python, so we can then learn new interesting stuff without being caught up on the basics.\n\nUltimately, the goal of this course is to be more applied.\n\nIf you’re already familiar with the basics of Python you’re welcome to jump in, but if at any point you find something difficult you may need to jump back to those fundamentals. They shouldn’t take too long if you’re already experienced.\n\nAs for operating system I highly recommend:\n\n1. You follow this on a Unix / Linux System (Ubuntu, Mac OS, etc), OR\n2. Run through WSL (Get full linux capabilities within your windows machine), OR\n3. You are willing to learn the differences for windows on your own (variations in commands, file structure, etc). This can introduce various challenges such as issues with operating-system specific packages, but if you’re comfortable going this route you’re welcome to. If you go this route at minimum you can use Git Bash to get similar commands on windows.\n\nIf you run in to issues, ask in the community. I’m constantly in there trying to help so you don’t get stuck.\n\n## Main things we will talk about in this Section\n\nEnvironment setup - tons of tools, it’s overwhelming. So I will show you the ones you need to care about and should start using. Especially annoying since everything has to have “Py” in it. PyPy, PyPi, etc.\n\nFormatting - We will get tools setup to help force us to write better code (linting, formatting).\n\nDependency Management - pip and uv, two important tools. Working with multiple versions of Python\n\nCpython and how python works behind the scenes.\n\nThis will flow in to the next section, where we’ll talk about wheels and get a better idea of how packages work.\n\n> [!tip]\n> This course has a different approach. Hands on, more focused on learning exactly the things we need and less on general concepts.\n> That being said it is still going to transfer well to other languages.\n\n## What should we expect over the next few weeks?\n\nWe’re going to try to get very familiar with:\n\n- Tools or packages that help us make better software,\n- Quality assurance by understanding types, data validation, and reducing runtime errors,\n- The standard library, things that are included with Python that we can utilize,\n- Important packages outside of the standard library,\n- Parsing and manipulating data. A very common use case with Python,\n- Exposure to some advanced topics to lay the foundation for you to go in to deeper studies.\n\nThen, once we finish these foundations we will explore AI and machine learning. We’ll explore what we’ll cover there later once we get to those sections.",[],[],"809f1708-9e87-4a5a-b708-d533b6878206",740,"e5e2bf42-1298-4bd2-916b-f965f65aa1d5","Intermediate Python Fundamentals",[811,812,813,814,815,816,817,818,819,820,821],{"_63":883,"_65":884,"_67":68,"_439":127,"_441":18,"_452":885,"_453":808,"_454":886,"_456":887,"_458":-5,"_459":-5,"_461":-5,"_463":-5,"_465":-5,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":877,"_65":878,"_67":68,"_439":490,"_441":18,"_452":-5,"_453":808,"_454":879,"_456":880,"_458":-5,"_459":881,"_461":882,"_463":464,"_465":840,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":871,"_65":872,"_67":68,"_439":482,"_441":18,"_452":-5,"_453":808,"_454":873,"_456":874,"_458":-5,"_459":875,"_461":876,"_463":464,"_465":840,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":865,"_65":866,"_67":68,"_439":474,"_441":18,"_452":-5,"_453":808,"_454":867,"_456":868,"_458":-5,"_459":869,"_461":870,"_463":464,"_465":466,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":859,"_65":860,"_67":68,"_439":451,"_441":18,"_452":-5,"_453":808,"_454":861,"_456":862,"_458":-5,"_459":863,"_461":864,"_463":464,"_465":840,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":853,"_65":854,"_67":68,"_439":680,"_441":18,"_452":-5,"_453":808,"_454":855,"_456":856,"_458":-5,"_459":857,"_461":858,"_463":464,"_465":466,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":847,"_65":848,"_67":68,"_439":637,"_441":18,"_452":-5,"_453":808,"_454":849,"_456":850,"_458":-5,"_459":851,"_461":852,"_463":464,"_465":466,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":841,"_65":842,"_67":68,"_439":593,"_441":18,"_452":-5,"_453":808,"_454":843,"_456":844,"_458":-5,"_459":845,"_461":846,"_463":464,"_465":466,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":834,"_65":835,"_67":68,"_439":549,"_441":18,"_452":-5,"_453":808,"_454":836,"_456":837,"_458":-5,"_459":838,"_461":839,"_463":464,"_465":840,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":828,"_65":829,"_67":68,"_439":505,"_441":18,"_452":-5,"_453":808,"_454":830,"_456":831,"_458":-5,"_459":832,"_461":833,"_463":464,"_465":466,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":822,"_65":823,"_67":68,"_439":440,"_441":18,"_452":-5,"_453":808,"_454":824,"_456":825,"_458":-5,"_459":826,"_461":827,"_463":464,"_465":466,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},"cfcf5c88-a66e-49d4-a659-4ad9ff993845","10 - Databases and SDKs",[],[],"025b066a-38fe-4764-a393-7c990f33a995",2696,"16bf981c-3837-4d56-b4c7-0daef346ff6a","9 - Input and Output with Objects",[],[],"6042c9dd-54dc-46bd-8b22-c48f405099d6",1612,"f9fce77f-37e4-484e-9736-10c50270ce53","8 - Object Oriented Programming",[],[],"f82da17f-b987-40f1-8597-0463a11aa88b",1182,2156,"f902e879-8096-4ce8-a7bb-a70bf0152936","7 - Dictionaries and Sets",[],[],"fa71c74d-aaf3-4bb1-9316-01c628cbe24f",1338,"8381f73f-6649-426c-b511-e178dac398da","6 - Modules",[],[],"1b722049-7d85-4af4-b057-a7a62221c016",837,"a9605a24-1604-466d-a75e-6fc6a1b73971","5 - 2D Lists",[],[],"3bcc8b81-da6c-4f4e-8866-15f78bb85197",784,"34f5f730-0f2d-4c2e-b474-6490e27753b1","4 - Basic IO",[],[],"95a2cf55-6417-4ec0-89a7-3a44d226017c",760,"0a595384-49b2-40ed-a085-f92020a67479","3 - Sorting",[],[],"48e7c497-2834-4412-a0f1-b1c82b96661d",554,"6156b3a1-f668-4827-9271-b2fc27732558","2 - Lists Continued",[],[],"0a99be9d-158d-4f11-807d-10699841f789",621,"f1749ea4-7c55-4791-a4db-76af6f09d460","1 - Working with Lists",[],[],"d53c7107-89ee-4f31-a17a-c2ebeab9ed13",831,"abaa9b96-40e9","A quick Note and Important Links","**Get the associated [Intermediate Programming eBook](https://calebcurry.notion.site/Intermediate-Programming-22570040f36980a7b9f8ea7e6bde57b2?source=copy_link)**\n\nThis section is from my fundamentals course that I included here. Rather than repeat myself, I figured I'd include the Python fundamentals so that we can focus on applied concepts in future lessons for this course. \n\nYou will want to understand pretty much everything in this. If you have any confusion bring it up in the community!\n\nENJOY!",[],[],"59b697be-22cf-456a-b6e0-d40f10d3497f","Beginner Python Fundamentals",[891,892,893,894,895,896,897,898,899,900,901,902],{"_63":972,"_65":973,"_67":68,"_439":127,"_441":18,"_452":974,"_453":888,"_454":975,"_456":976,"_458":-5,"_459":-5,"_461":-5,"_463":-5,"_465":-5,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":966,"_65":967,"_67":68,"_439":490,"_441":18,"_452":-5,"_453":888,"_454":968,"_456":969,"_458":-5,"_459":970,"_461":971,"_463":910,"_465":911,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":960,"_65":961,"_67":68,"_439":482,"_441":18,"_452":-5,"_453":888,"_454":962,"_456":963,"_458":-5,"_459":964,"_461":965,"_463":910,"_465":911,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":954,"_65":955,"_67":68,"_439":474,"_441":18,"_452":-5,"_453":888,"_454":956,"_456":957,"_458":-5,"_459":958,"_461":959,"_463":910,"_465":911,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":948,"_65":949,"_67":68,"_439":451,"_441":18,"_452":-5,"_453":888,"_454":950,"_456":951,"_458":-5,"_459":952,"_461":953,"_463":910,"_465":911,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":942,"_65":943,"_67":68,"_439":680,"_441":18,"_452":-5,"_453":888,"_454":944,"_456":945,"_458":-5,"_459":946,"_461":947,"_463":910,"_465":911,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":936,"_65":937,"_67":68,"_439":637,"_441":18,"_452":-5,"_453":888,"_454":938,"_456":939,"_458":-5,"_459":940,"_461":941,"_463":910,"_465":911,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":930,"_65":931,"_67":68,"_439":593,"_441":18,"_452":-5,"_453":888,"_454":932,"_456":933,"_458":-5,"_459":934,"_461":935,"_463":910,"_465":911,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":924,"_65":925,"_67":68,"_439":549,"_441":18,"_452":-5,"_453":888,"_454":926,"_456":927,"_458":-5,"_459":928,"_461":929,"_463":910,"_465":911,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":918,"_65":919,"_67":68,"_439":505,"_441":18,"_452":-5,"_453":888,"_454":920,"_456":921,"_458":-5,"_459":922,"_461":923,"_463":910,"_465":911,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":912,"_65":913,"_67":68,"_439":440,"_441":18,"_452":-5,"_453":888,"_454":914,"_456":915,"_458":-5,"_459":916,"_461":917,"_463":910,"_465":911,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},{"_63":903,"_65":904,"_67":68,"_439":905,"_441":18,"_452":-5,"_453":888,"_454":906,"_456":907,"_458":-5,"_459":908,"_461":909,"_463":910,"_465":911,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},"e559be0c-228a-4c2e-8ab4-a038db55f187","10 - Functions",11,[],[],"af37a5f4-4d4b-49c8-9baf-87836cd6f466",1155,1920,1080,"eb88d8b0-4dbd-42fd-bf44-bbf28f926b69","9 - Nested While Loops",[],[],"6f545c0e-f0f9-4503-9e9f-ef837da4ff0d",267,"d9e66ebe-8b45-4ffa-bfc4-04435be85644","8 - Nested Control Flow",[],[],"68ae51f6-ab82-484f-aa13-e45559e43c18",516,"a4c04f43-390d-4bf8-bc7e-56924f441c97","7 - More on Loops",[],[],"0286efba-bc82-4ca4-b7ef-814d7dc3dbc4",1051,"8f8de25d-0f88-4d3c-a0de-f5b88484bae9","6 - Loops",[],[],"94e69208-9e34-4854-a62b-648f0a16dcc6",787,"387a29cb-840c-4ba4-9a9c-d6698e1b3027","5 - Logic and if Statements",[],[],"0a2e5535-ab0f-478a-8abc-0e33f76ca315",817,"59529e21-c097-48d8-a606-f2b0f5fcc8c2","4 - User Input",[],[],"03159f55-38dc-47cd-a522-382eb3271668",445,"e3772623-f510-46f0-937a-045cff186716","3 - Lists",[],[],"28a4a3e7-b20f-44e7-b437-deeac175ec00",1028,"75642176-9943-4c82-ad32-6824f0608a3a","2 - Strings",[],[],"c707e032-2711-4839-b126-f2275e8d3ae1",1298,"1dad8a5b-db9f-4570-b267-6ac5e1539249","1 - Numbers",[],[],"f1150be7-8dc7-49b1-9fba-c8f30f6b812b",1037,"d8f9d676-e9eb-4d93-9dfa-522388282bf7","Code Editor Setup",[],[],"13e8fa3f-241e-4732-a04f-1ba1adc99864",730,"c5c8e51d-9bec","A Quick Note and Important Links","**Get the associated [Beginner Programming eBook](https://calebcurry.notion.site/Beginner-Programming-22570040f36980f8974cca28ecd3a660?source=copy_link)**\n\nThis section is from my fundamentals course that I included here. Rather than repeat myself, I figured I'd include the Python fundamentals so that we can focus on applied concepts in future lessons for this course. \n\nYou will want to understand pretty much everything in this. If you have any confusion bring it up in the community!\n\nENJOY!",[],[],"e9a04d81-1020-48de-990f-ccec42cf7b97","Resources",[980],{"_63":981,"_65":982,"_67":68,"_439":127,"_441":18,"_452":983,"_453":977,"_454":984,"_456":985,"_458":-5,"_459":-5,"_461":-5,"_463":-5,"_465":-5,"_467":18,"_468":469,"_470":18,"_471":-5,"_86":18,"_88":-5,"_89":-5,"_82":83},"a1c31bc4-09bb-48e9-b919-9bf49b331723","eBook and Community","**1. Join the community [here](https://calcur.tech/community).**\n\n**2. Access the [eBook](https://calebcurry.notion.site/Python-Mastery-22470040f36980d78739ea1b88ab0c07?source=copy_link).**\n\n**Any questions at all about your account or the course platform should first be asked in the community. If you're having issues joining the community, reach out at caleb@calebcurry.com**\n\nOnce you sign up be sure to introduce yourself to the group :)",[],[],{"_63":401,"_114":115,"_116":296,"_67":68,"_118":338,"_82":83},"faviconUrl","tenantName","externalCommunityEnabled","externalCommunityUrl","https://calcur.tech/community","contactEmail","isPrivateTenant","facebookPixelId","umamiWebsiteId","30134907-2cb0-4c56-b7cb-3cae8dd6f4f4"]

Locked Content