FastAPI बैकएंड डेवलपमेंट बूटकैंप · पाठ

Beanie ODM के साथ दस्तावेज़ मॉडलिंग

Pydantic के ऊपर Beanie का उपयोग करके टाइपयुक्त दस्तावेज़ मॉडल, इंडेक्स और एम्बेडेड संरचनाएँ परिभाषित कीजिए।

पाठ 2, कुल 4 में से13 चरण

Beanie ODM के साथ दस्तावेज़ मॉडलिंग, CoddyKit पर FastAPI बैकएंड डेवलपमेंट बूटकैंप का एक निःशुल्क पाठ है। यह 4 में से 2वाँ पाठ है। इस अध्ययन पथ के 3 तक कोई भी पाठ पूरा पढ़ना निःशुल्क है — इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ व्यावहारिक अभ्यास भी उपलब्ध कराता है। यह FastAPI बैकएंड डेवलपमेंट बूटकैंप सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। FastAPI बैकएंड डेवलपमेंट बूटकैंप पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

Beanie FastAPI के लिए क्या लाता है

Beanie MongoDB के लिए एक async ODM (ऑब्जेक्ट-दस्तावेज़ मैपर) है, जो सीधे Pydantic और async motor ड्राइवर पर बनाया गया है। FastAPI बैकएंड में यह आपको टाइप-जाँचे और सत्यापित दस्तावेज़ देता है, जो अनुरोध और प्रतिक्रिया बॉडी के लिए आपके पहले से उपयोग किए जा रहे Pydantic मॉडल जैसे ही लगते हैं।

हर दस्तावेज़ क्लास एक MongoDB कलेक्शन से मैप होती है।
हर इंस्टेंस एक दस्तावेज़ (JSON जैसा रिकॉर्ड) से मैप होता है।
सत्यापन, क्रमबद्धता और JSON Schema Pydantic v2 से बिना अतिरिक्त प्रयास के मिलते हैं।

क्योंकि सब कुछ async है, Beanie स्वाभाविक रूप से FastAPI के async रूट हैंडलरों के साथ काम करता है और डेटाबेस I/O के दौरान इवेंट लूप को रुकने से बचाता है।

अपना पहला दस्तावेज़ मॉडल

Beanie मॉडल, Pydantic के BaseModel के बजाय Document को सबक्लास करता है। फ़ील्ड सामान्य प्रकार संकेतों के साथ घोषित किए जाते हैं और Beanie हर दस्तावेज़ को MongoDB के _id (एक ObjectId) पर आधारित id फ़ील्ड अपने-आप देता है।

आवश्यक फ़ील्ड का कोई डिफ़ॉल्ट नहीं होता; वैकल्पिक फ़ील्ड Optional[...] या डिफ़ॉल्ट मान का उपयोग करते हैं।
कलेक्शन का नाम क्लास के नाम से प्राप्त होता है, जब तक कि आप उसे बदल न दें।

नीचे, Product उत्पाद दस्तावेज़ों का एक कलेक्शन बन जाता है।

from typing import Optional
from beanie import Document


class Product(Document):
    name: str
    price: float
    description: Optional[str] = None
    in_stock: bool = True


# An instance is just a validated Pydantic object until you insert it
item = Product(name="Keyboard", price=49.9)
print(item.name, item.price, item.in_stock)

Settings से कलेक्शन कॉन्फ़िगर करना

Beanie किसी आंतरिक class Settings से वैकल्पिक कॉन्फ़िगरेशन पढ़ता है। सबसे सामान्य विकल्प name है, जो क्लास के नाम पर निर्भर रहने के बजाय MongoDB कलेक्शन का नाम स्पष्ट रूप से निर्धारित करता है।

name — कलेक्शन का नाम।
use_state_management — आंशिक सेव के लिए बदले गए फ़ील्ड का रिकॉर्ड रखता है।
validate_on_save — मौजूदा दस्तावेज़ को सेव करते समय सत्यापन फिर से चलाता है।

कलेक्शन का नाम स्थिर रखने से Python क्लास का नाम बाद में बदलने पर भी आपका स्कीमा स्थिर रहता है।

from beanie import Document


class Product(Document):
    name: str
    price: float

    class Settings:
        name = "products"
        validate_on_save = True


print(Product.Settings.name)

ऐप स्टार्टअप पर Beanie को इनिशियलाइज़ करना

किसी भी दस्तावेज़ के MongoDB से बात करने से पहले आपको अपने motor डेटाबेस और दस्तावेज़ मॉडल की सूची देते हुए init_beanie को एक बार कॉल करना होगा। FastAPI में इसे lifespan हैंडलर में रखा जाता है, ताकि यह स्टार्टअप पर चले।

AsyncIOMotorClient async कनेक्शन बनाता है।
document_models हर मॉडल को पंजीकृत करता है, ताकि Beanie इंडेक्स और क्वेरी बना सके।

यह फ़्रेमवर्क/सर्वर वायरिंग है — इसके लिए सक्रिय MongoDB चाहिए, इसलिए इसे स्वतंत्र स्क्रिप्ट नहीं, बल्कि सेटअप पैटर्न मानें।

from contextlib import asynccontextmanager
from fastapi import FastAPI
from motor.motor_asyncio import AsyncIOMotorClient
from beanie import init_beanie


@asynccontextmanager
async def lifespan(app: FastAPI):
    client = AsyncIOMotorClient("mongodb://localhost:27017")
    await init_beanie(
        database=client.shop_db,
        document_models=[Product],
    )
    yield
    client.close()


app = FastAPI(lifespan=lifespan)

Pydantic से फ़ील्ड सत्यापन

क्योंकि Document एक Pydantic मॉडल है, इसलिए आपके परिचित सभी सत्यापन उपकरण अब भी काम करते हैं: Field प्रतिबंध, कस्टम सत्यापक और EmailStr या HttpUrl जैसे समृद्ध प्रकार।

Field(gt=0) गैर-सकारात्मक कीमतों को अस्वीकार करता है।
Field(min_length=...) स्ट्रिंग की लंबाई लागू करता है।
ऑब्जेक्ट बनाए जाने पर सत्यापन चलता है, इसलिए खराब डेटा MongoDB तक नहीं पहुँचता।

यह स्निपेट शुद्ध Pydantic-शैली का सत्यापन है और अपने-आप चलता है।

from pydantic import BaseModel, Field, ValidationError


class Product(BaseModel):
    name: str = Field(min_length=1, max_length=80)
    price: float = Field(gt=0)
    sku: str = Field(pattern=r"^[A-Z]{3}-\d{4}$")


try:
    Product(name="Mouse", price=-5, sku="bad")
except ValidationError as e:
    print("Rejected:", len(e.errors()), "errors")

good = Product(name="Mouse", price=19.99, sku="MOU-0001")
print("Accepted:", good.sku)

Indexed से इंडेक्स घोषित करना

इंडेक्स क्वेरी को तेज़ बनाते हैं और विशिष्टता लागू कर सकते हैं। Beanie दो शैलियाँ उपलब्ध कराता है। सबसे सरल शैली किसी फ़ील्ड के प्रकार पर Indexed रैपर लगाना है, जिससे एकल-फ़ील्ड इंडेक्स बनता है।

Indexed(str, unique=True) एक विशिष्ट इंडेक्स बनाता है — ईमेल या SKU के लिए बिल्कुल उपयुक्त।
Beanie init_beanie के दौरान इंडेक्स अपने-आप बनाता है।

केवल ऐप की जाँच पर निर्भर रहने के बजाय अखंडता के नियम डेटाबेस में लागू करने के लिए विशिष्ट इंडेक्स का उपयोग करें।

import pymongo
from beanie import Document, Indexed
from pydantic import EmailStr


class User(Document):
    email: Indexed(EmailStr, unique=True)
    username: Indexed(str)
    age: int

    class Settings:
        name = "users"

Settings में संयुक्त इंडेक्स

बहु-फ़ील्ड या उन्नत इंडेक्स के लिए उन्हें PyMongo के IndexModel का उपयोग करके Settings.indexes में घोषित करें। इसी तरह आप संयुक्त इंडेक्स बनाते हैं, क्रम की दिशा नियंत्रित करते हैं या TTL जोड़ते हैं।

दिशाओं के साथ फ़ील्ड की सूची दें: pymongo.ASCENDING / DESCENDING।
IndexModel के माध्यम से unique=True या expireAfterSeconds=... दें।

क्रम महत्वपूर्ण है: (category, price) पर बना संयुक्त इंडेक्स उन क्वेरी को बेहतर बनाता है जो category से फ़िल्टर करके फिर price के अनुसार क्रमबद्ध करती हैं।

import pymongo
from pymongo import IndexModel
from beanie import Document


class Product(Document):
    name: str
    category: str
    price: float

    class Settings:
        name = "products"
        indexes = [
            IndexModel(
                [("category", pymongo.ASCENDING), ("price", pymongo.DESCENDING)],
                name="category_price_idx",
            ),
        ]

BaseModel से एम्बेडेड दस्तावेज़

MongoDB नेस्टेड ऑब्जेक्ट को एक ही दस्तावेज़ के भीतर संग्रहीत करता है। Beanie में एम्बेडेड संरचना फ़ील्ड प्रकार के रूप में उपयोग किया गया एक साधारण Pydantic BaseModel है — यह अलग कलेक्शन नहीं है और इसका कोई id नहीं होता।

जब नेस्टेड डेटा पैरेंट के स्वामित्व में हो और हमेशा साथ पढ़ा जाता हो, तब उसे एम्बेड करें (जैसे उपयोगकर्ता के भीतर पता)।
पूरी संरचना का एक ही दस्तावेज़ के रूप में सत्यापन और क्रमबद्धता होती है।

यहाँ Address को User दस्तावेज़ के भीतर एम्बेड किया गया है।

from pydantic import BaseModel
from beanie import Document


class Address(BaseModel):
    street: str
    city: str
    postal_code: str


class User(Document):
    name: str
    address: Address

    class Settings:
        name = "users"


u = User(name="Ada", address=Address(street="1 Main", city="Oslo", postal_code="0150"))
print(u.address.city)

एम्बेडेड संरचनाओं की सूचियाँ

किसी दस्तावेज़ फ़ील्ड में एम्बेडेड मॉडलों की सूची हो सकती है। यह पूरी तरह पैरेंट से संबंधित one-to-many डेटा के लिए आदर्श है — जैसे ऑर्डर की पंक्ति की वस्तुएँ या टिप्पणियाँ।

list[OrderItem] निर्माण के समय हर तत्व का सत्यापन करता है।
हर आइटम को उसी स्थान पर क्रमबद्ध किया जाता है, इसलिए ऑर्डर पढ़ने के लिए कोई अतिरिक्त क्वेरी आवश्यक नहीं होती।

जब कलेक्शन की सीमा निश्चित हो और उसे पैरेंट के साथ पढ़ा जाए, तब एम्बेडेड सूचियों को प्राथमिकता दें; जब वह असीमित रूप से बढ़े, तब संदर्भों का उपयोग करें।

from pydantic import BaseModel
from beanie import Document


class OrderItem(BaseModel):
    product_name: str
    quantity: int
    unit_price: float


class Order(Document):
    customer: str
    items: list[OrderItem]

    class Settings:
        name = "orders"

    @property
    def total(self) -> float:
        return sum(i.quantity * i.unit_price for i in self.items)


order = Order(
    customer="Lin",
    items=[OrderItem(product_name="Pen", quantity=3, unit_price=1.5)],
)
print(order.total)

Link से अन्य दस्तावेज़ों का संदर्भ देना

जब संबंधित डेटा अपने अलग कलेक्शन में रहता हो और साझा या बड़ा हो, तब एम्बेड करने के बजाय संदर्भ का उपयोग करें। Beanie का Link[OtherDocument] एक पॉइंटर (DBRef) संग्रहीत करता है और आवश्यकता पड़ने पर लिंक किए गए दस्तावेज़ को प्राप्त कर सकता है।

Link[Category] category को अपने अलग कलेक्शन में रखता है।
इसे हल करने के लिए क्वेरी पर fetch_links=True या await doc.fetch_link(...) का उपयोग करें।

सामान्य नियम: स्वामित्व वाले और साथ पढ़े जाने वाले डेटा को एम्बेड करें; साझा या स्वतंत्र रूप से क्वेरी किए जाने वाले डेटा को लिंक करें।

from beanie import Document, Link


class Category(Document):
    name: str

    class Settings:
        name = "categories"


class Product(Document):
    name: str
    price: float
    category: Link[Category]

    class Settings:
        name = "products"

मॉडलिंग विकल्प: एम्बेड करें या संदर्भ दें

दस्तावेज़ मॉडलिंग में मुख्य डिज़ाइन निर्णय यह होता है कि डेटा को एम्बेड किया जाए या उसका संदर्भ दिया जाए। इसका कोई सार्वभौमिक उत्तर नहीं है — यह डेटा तक पहुँचने के तरीकों और डेटा के आकार पर निर्भर करता है।

एम्बेड तब करें जब: चाइल्ड, पैरेंट के स्वामित्व में हो, हमेशा साथ लोड किया जाता हो और उसका आकार सीमित हो (पता, ऑर्डर आइटम)।
संदर्भ तब दें जब: डेटा कई दस्तावेज़ों में साझा किया जाता हो, स्वतंत्र रूप से क्वेरी किया जाता हो या बिना सीमा के बढ़ सकता हो (श्रेणियाँ, लेखक, ऑडिट लॉग)।

MongoDB दस्तावेज़ों की अधिकतम सीमा 16 MB होती है, इसलिए बिना सीमा वाली एम्बेड की गई सारणियाँ अंततः समस्या पैदा करेंगी — बड़ी और लगातार बढ़ने वाली संग्रहणियों का संदर्भ देने का यह एक और कारण है।

त्वरित जाँच: एम्बेड करें या संदर्भ दें?

आप Beanie के साथ एक ई-कॉमर्स बैकएंड का मॉडल बना रहे हैं। एक Product केवल एक Category से संबंधित है, श्रेणियाँ हज़ारों उत्पादों में साझा की जाती हैं, और आप अक्सर सभी श्रेणियों को उनके अलग प्रशासन पृष्ठ पर सूचीबद्ध करते हैं।

इंटरैक्टिव पाठ में इसका उत्तर दें

पुनरावृत्ति: Beanie के साथ दस्तावेज़ मॉडलिंग

आपने सीखा कि Pydantic के ऊपर Beanie का उपयोग करके MongoDB डेटा का मॉडल कैसे बनाया जाता है:

दस्तावेज़ उपवर्ग किसी Python क्लास को एक संग्रह से मैप करते हैं; class Settings संग्रह का नाम और विकल्प निर्धारित करता है।
init_beanie को स्टार्टअप के समय (FastAPI के लाइफ़टाइम में) आपके मोटर डेटाबेस और document_models के साथ चलना आवश्यक है।
Pydantic के Field प्रतिबंध और वैधता-जाँचकर्ता खराब डेटा को डेटाबेस में जाने से रोकते हैं।
एकल फ़ील्ड के लिए Indexed रैपर से और मिश्रित तथा अद्वितीय इंडेक्स के लिए Settings.indexes + IndexModel से इंडेक्स बनाएँ।
स्वामित्व वाले, सीमित और साथ पढ़े जाने वाले डेटा को नेस्टेड BaseModel के रूप में एम्बेड करें; साझा या बढ़ते डेटा के लिए Link[...] के साथ संदर्भ दें और 16 MB दस्तावेज़ सीमा का ध्यान रखें।

इन उपकरणों से आप अपने FastAPI बैकएंड के लिए प्रकार-सुरक्षित, सत्यापित और क्वेरी के लिए कुशल MongoDB स्कीमा डिज़ाइन कर सकते हैं।

शुरुआत निःशुल्क

एआई शिक्षक के साथ FastAPI बैकएंड डेवलपमेंट बूटकैंप सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 21
पाठ: 84

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “Beanie ODM के साथ दस्तावेज़ मॉडलिंग” पाठ निःशुल्क है?

हाँ — FastAPI बैकएंड डेवलपमेंट बूटकैंप अध्ययन पथ के 3 तक कोई भी पाठ, जिसमें “Beanie ODM के साथ दस्तावेज़ मॉडलिंग” भी शामिल है, यहाँ वेब पर पूरा पढ़ना निःशुल्क है। इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ इंटरैक्टिव अभ्यास भी उपलब्ध कराता है। FastAPI बैकएंड डेवलपमेंट बूटकैंप पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“Beanie ODM के साथ दस्तावेज़ मॉडलिंग” में मैं क्या सीखूँगा?

Pydantic के ऊपर Beanie का उपयोग करके टाइपयुक्त दस्तावेज़ मॉडल, इंडेक्स और एम्बेडेड संरचनाएँ परिभाषित कीजिए। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ FastAPI बैकएंड डेवलपमेंट बूटकैंप का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या FastAPI बैकएंड डेवलपमेंट बूटकैंप शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर FastAPI बैकएंड डेवलपमेंट बूटकैंप शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 2वाँ पाठ है।

“Beanie ODM के साथ दस्तावेज़ मॉडलिंग” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस FastAPI बैकएंड डेवलपमेंट बूटकैंप पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर FastAPI बैकएंड डेवलपमेंट बूटकैंप पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

← FastAPI बैकएंड डेवलपमेंट बूटकैंप पर वापस जाएँ