HTरूटिंग

te में एक सरल लेकिन शक्तिशाली अनुरोध रूटिंग सिस्टम है। रूटिंग टेबल को मार्गों की सूची के रूप में परिभाषित किया गया है और एप्लिकेशन को तत्काल पारित किए जाने पर पारित किया जाता है।

te.से आयात
से te.आयात T
स्टारलेट से। रूटिंग आयात मार्ग


Ac def मुखपृष्ठ (अनुरोध):
    वापसी प्लेनटेक्सटरिस्पांस ("होमपेज")

Ac def के बारे में (request):
    प्लेनटेक्स रिस्पांस लौटाता है ("About")


मार्ग = [
    मार्ग ("/", समापन बिंदु = मुखपृष्ठ),
    मार्ग ("/ के बारे में", समापन बिंदु = के बारे में),
]

ऐप = स्टारलेट (routes = routes)

endpoint पैरामीटर निम्नलिखित में से एक हो सकते हैं:

• एक नियमित या अतुल्यकालिक फ़ंक्शन जो स्वीकार करता है request एकल तर्क, और एक प्रतिक्रिया वापस करनी चाहिए।
• एक वर्ग जो ASGI इंटरफेस को लागू करता है, जैसे कि te का HTTPEndpoint।

पथ पैरामीटर

पथ घटकों को कैप्चर करने के लिए पथ URI टेम्पलेट शैलियों का उपयोग कर सकते हैं।

रूट ('/ users/{username}', user)

डिफ़ॉल्ट रूप से, यह पथ के अंत या अगले एक तक वर्णों को कैप्चर करेगा / ...

आप कैप्चर की गई सामग्री को संशोधित करने के लिए कनवर्टर का उपयोग कर सकते हैं। उपलब्ध कनवर्टर हैं:

• str एक स्ट्रिंग लौटाता है और डिफ़ॉल्ट मान है।
• int एक पायथन पूर्णांक लौटाता है।
• float एक पायथन फ्लोटिंग-पॉइंट नंबर लौटाता है।
• uuid एक अजगर लौटें uuid.UUID उदाहरण।
• path किसी भी अतिरिक्त सहित शेष पथ पर लौटें / चरित्र।

कनवर्टर का उपयोग बृहदान्त्र के साथ उपसर्ग करके किया जाता है, इस प्रकार है:

रूट ('/ users/{user_id:int}', user)
रूट ('/ फ्लोटिंग-पॉइंट /{number:float}', फ्लोटिंग _ पॉइंट)
मार्ग ('/ अपलोड /{rest_of_path:path}', अपलोड किया गया)

यदि आपको एक अपरिभाषित अलग कनवर्टर की आवश्यकता है, तो आप अपना खुद का बना सकते हैं।datetime कनवर्टर बनाने के तरीके और इसे पंजीकृत करने के तरीके के उदाहरण के लिए नीचे देखें:

डेटटाइम आयात डेटटाइम से

से te.आयात कनवर्टर, रजिस्टर _ url _ कनवर्टर


कक्षा Datee(कनवर्टर):
    रेगेक्स = "[0-9]{4}- [0-9]{2}- [0-9]{2}टी [0-9]{2}: [0-9]{2}: [0-9]{2}(. [0-9] +)? "

    डेफ कन्वर्ट (self, value: str) - > दिनांक:
        date.strptime लौटाता है (मूल्य, "% Y-% m-% dT% H:% M:% S")

    Dto _ स्ट्रिंग (स्व, मूल्य: datetime) -> str:
        वापसी मान ("% Y-% m-% dT% H:% M:% S")

रजिस्टर _ url _ कनवर्टर ("datetime", Datee()

पंजीकरण करने के बाद, आप इसका उपयोग करने में सक्षम होंगे:

मार्ग ('/ इतिहास /{date:datetime}', इतिहास)

पथ पैरामीटर अनुरोध में उपलब्ध है request.path_params एक शब्दकोश।

Ac def उपयोगकर्ता (अनुरोध):
    user_id = अनुरोध। path_params ['user_id']
    ...

HTतरीकों को संभालना

रूटिंग यह भी निर्दिष्ट कर सकती है कि कौन सा HTएंडपॉइंट हैंडल करता है।

रूट ('/ users/{user_id:int}', उपयोगकर्ता, तरीके = ["GET", "POST"])

डिफ़ॉल्ट रूप से, फ़ंक्शन समापन बिंदु केवल स्वीकार करेंगे GET अनुरोध, जब तक कि अन्यथा निर्दिष्ट न हो।

उप-आधार बढ़ते वायरिंग

बड़े अनुप्रयोगों में, आप पा सकते हैं कि आप सामान्य पथ उपसर्गों के आधार पर रूटिंग तालिका के कुछ हिस्सों को विभाजित करना चाहते हैं।

मार्ग = [
    मार्ग ('/', homepage),
    माउंट ('/ उपयोगकर्ता', मार्ग = [
        रूट ('/', उपयोगकर्ता, तरीके = ['GET', 'POST']),
        मार्ग ('/{username}', उपयोगकर्ता),
    ])
]

यह शैली आपको परियोजना के विभिन्न भागों में रूटिंग टेबल के विभिन्न सबसेट को परिभाषित करने की अनुमति देती है।

से आयात उपयोगकर्ताओं, auth

मार्ग = [
    मार्ग ('/', homepage),
    माउंट ('/ users', मार्गों = users.roots),
    माउंट ('/auth', मार्गों = auth.routs),
]

आप अपने te एप्लिकेशन में चाइल्ड एप्लिकेशन शामिल करने के लिए माउंट का भी उपयोग कर सकते हैं। उदाहरण के लिए...

# यह एक स्टैंडअलोन स्टैटिक फाइल सर्वर है:
ऐप = स्टेटिक फाइलें (directory = "static")

# यह एक स्थिर फ़ाइल सर्वर है जो एक te एप्लिकेशन के भीतर लगाया गया है,
# "/ स्थिर" पथ के नीचे।
मार्ग = [
    ...
    माउंट ("/ स्थैतिक", ऐप = स्टेटिकफाइल्स (directory = "static"), नाम = "स्थिर")
]

ऐप = स्टारलेट (routes = routes)

रिवर्स लुकअप

आप आमतौर पर विशिष्ट मार्गों के लिए URL उत्पन्न करने में सक्षम होना चाहते हैं, जैसे कि उन स्थितियों में जहां आपको पुनर्निर्देशित प्रतिक्रिया वापस करने की आवश्यकता होती है।

• हस्ताक्षर: url_for(name, **path_params) -> URL

  मार्ग = [मार्ग ("/", मुखपृष्ठ, नाम = "मुखपृष्ठ")]

  हम एक वापस करने के लिए निम्नलिखित का उपयोग कर सकते हैं ...

  url = request.url_for ("होम")

लुकअप में पथ पैरामीटर शामिल हो सकते हैं ...

मार्ग = [
    मार्ग ("/users/{username}, "उपयोगकर्ता, नाम =" user_detail")
]

# हम एक वापस करने के लिए निम्नलिखित का उपयोग कर सकते हैं ...
url = अनुरोध। url _ for ("user_detail", उपयोगकर्ता नाम = ...)

अगर एक Mount एक शामिल करें name फिर आधार का उपयोग किया जाना चाहिए {prefix}:{name} रिवर्स लुकअप के लिए स्टाइल।

मार्ग = [
    माउंट ("/ उपयोगकर्ता", नाम = "उपयोगकर्ता", मार्ग = [
        रूट ("/", उपयोगकर्ता, नाम = "user_list"),
        रूट ("/{username}", उपयोगकर्ता, नाम = "user_detail")
    ])
]

# हम URL वापस करने के लिए निम्नलिखित का उपयोग कर सकते हैं ...
url = request.url_for ("users: user_list")
l = request.url_for ("उपयोगकर्ता: user_detail", उपयोगकर्ता नाम = ...)

स्थापित एप्लिकेशन में एक हो सकता है path=... पैरामीटर।

मार्ग = [
    ...
    माउंट ("/ स्थैतिक", ऐप = स्टेटिकफाइल्स (directory = "static"), नाम = "स्थिर")
]

# हम URL वापस करने के लिए निम्नलिखित का उपयोग कर सकते हैं ...
url = request.url_for ("स्थिर", पथ = "/css/base.css")

नहीं के लिए request उदाहरण के मामले में, आप कर सकते हैं एक रिवर्स लुकअप के खिलाफ आवेदन है, हालांकि इन लुकअप केवल वापस आ जाएगा पथ है ।

url = app.url_path_for ("user_detail", उपयोगकर्ता नाम = ...)

होस्ट-आधारित रूटिंग

यदि आप आधारित होना चाहते हैं Host हेडर एक ही पथ के लिए विभिन्न मार्गों का उपयोग करते हैं।

कृपया ध्यान दें कि मिलान करते समय, यह से शुरू होगा Host हेडर में पोर्ट हटाएं। उदाहरण के लिए, भले ही Host हेडर में शामिल है या इसके अलावा नहीं है 3600 ( example.org:5600 , example.org ) बंदरगाह के बाहर, Host (host='example.org:3600', ...) यह भी संसाधित किया जाएगा। इसलिए, यदि आप अंदर हैं url_for यदि आपको पोर्ट का उपयोग करने की आवश्यकता है, तो आप उस पोर्ट को निर्दिष्ट कर सकते हैं।

होस्ट-आधारित रूटिंग को अपने एप्लिकेशन से कनेक्ट करने के कई तरीके हैं

साइट = राउटर () # उदाहरण के लिए। `@site.route()` इसे कॉन्फ़िगर करने के लिए।
एपीआई = राउटर () # उदाहरण के लिए। `@api.route()` इसे कॉन्फ़िगर करने के लिए।
समाचार = राउटर () # उदाहरण के लिए। `@news.route()` इसे कॉन्फ़िगर करने के लिए।

मार्ग = [
    मेजबान api.example.org api, नाम = "site_api")
]

ऐप = स्टारलेट (routes = routes)

app.host www.example.org साइट, नाम = "main_site")

समाचार _ मेजबान = मेजबान ('news.example.org', news)
App.ter..end (news_host)

प्रश्नों में पथ मापदंडों की तरह होस्ट पैरामीटर शामिल हो सकते हैं

मार्ग = [
    होस्ट ("{subdomain}।" example.org नाम = "उप", ऐप = राउटर (मार्गों = [
        माउंट ("/ उपयोगकर्ता", नाम = "उपयोगकर्ता", मार्ग = [
            रूट ("/", उपयोगकर्ता, नाम = "user_list"),
            रूट ("/{username}", उपयोगकर्ता, नाम = "user_detail")
        ])
    ]))
]
...
l = request.url_for ("उप: उपयोगकर्ता: user_detail", उपयोगकर्ता नाम = ..., सबडोमेन = ...)
l = request.url_for ("उप: उपयोगकर्ता: user_list", सबडोमेन = ...)

मार्ग प्राथमिकता

आने वाला पथ प्रत्येक के साथ क्रमबद्ध करना में है Route एक मैच बनाओ।

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

उदाहरण के लिए:

# ऐसा मत करो: `/users/me` आने वाले अनुरोधों से कभी मेल नहीं खाएगा।
मार्ग = [
    रूट ('/ users/{username}', user),
    रूट ('/users/me', current_user),
]

#यह करो: `/users/me` पहले परीक्षण किया जाता है।
मार्ग = [
    रूट ('/users/me', current_user),
    रूट ('/users/{username}', user),
]

राउटर उदाहरण के साथ काम करना

यदि आप निम्न स्तर पर काम कर रहे हैं, तो आप एक नियमित उपयोग करना चाह सकते हैं Router उदाहरण, बनाने के बजाय Starlette अनुप्रयोग। यह आपको एक हल्का ASGI एप्लिकेशन देता है जो केवल किसी भी मिडलवेयर में लपेटे बिना एप्लिकेशन रूटिंग प्रदान करता है।

ऐप = राउटर (मार्गों = [
    मार्ग ('/', homepage),
    माउंट ('/ उपयोगकर्ता', मार्ग = [
        रूट ('/', उपयोगकर्ता, तरीके = ['GET', 'POST']),
        रूट ('/{username}', उपयोगकर्ता),
    ])
])

वेबसॉकेट रूटिंग

एंडपॉइंट का उपयोग करते समय, आपको उपयोग करना चाहिए WebSocketRoute सामान्य के बजाय Route ...

पथ पैरामीटर और WebSocketRoute रिवर्स लुकअप HTके साथ काम करता है। Route इसी तरह, यह ऊपर HTरूटिंग अनुभाग में पाया जा सकता है।

te.से आयात
स्टारलेट से। रूटिंग आयात


Ac def websocet_index (websocet):
    प्रतीक्षा करें websocket.()
    वेबसॉकेट का इंतजार करें। send_text ("हैलो, वेबसॉकेट!")
    प्रतीक्षा करें websocket.()


Ac def websocet_user (websocet):
    नाम = वेबसॉकेट। path_params ["नाम"]
    प्रतीक्षा करें websocket.()
    प्रतीक्षा करें websocsend_text (f "हैलो,{name}")
    प्रतीक्षा करें websocket.()


मार्ग = [
    ("/", समापन बिंदु = websocket_index),
    वेबसॉकेटरूट ("/{name}", समापन बिंदु = वेबसॉकेट_user),
]

ऐप = स्टारलेट (routes = routes)

endpoint पैरामीटर निम्नलिखित में से एक हो सकते हैं:

• एक अतुल्यकालिक फ़ंक्शन जो एकल को स्वीकार करता है websocket पैरामीटर।
• एक वर्ग जो एएसजीआई इंटरफेस को लागू करता है, जैसे कि स्टारलेट का वेबसॉकेटएंडपॉइंट।