टर्बोगियर्स - त्वरित गाइड

वेब फ्रेमवर्क क्या है?

वेब एप्लिकेशन फ्रेमवर्क या बस वेब फ्रेमवर्क पुस्तकालयों और मॉड्यूल के संग्रह का प्रतिनिधित्व करता है, जो एक वेब एप्लिकेशन डेवलपर को प्रोटोकॉल, थ्रेड मैनेजमेंट, आदि जैसे निम्न स्तर के विवरण के बारे में परेशान किए बिना, एप्लिकेशन लिखने में सक्षम बनाता है।

TurboGears क्या है?

TurboGears पायथन में लिखा गया एक वेब एप्लिकेशन फ्रेमवर्क है। मूल रूप से 2005 में केविन डंगूर द्वारा निर्मित, इसका नवीनतम संस्करण TurboGears (ver 2.3.7) को मार्क रम्म और फ्लोरेंट एड के नेतृत्व में डेवलपर्स के एक समूह द्वारा प्रबंधित किया गया है।

TurboGears मॉडल-व्यू-कंट्रोलर प्रतिमान का अनुसरण करता है क्योंकि अधिकांश आधुनिक वेब फ्रेमवर्क जैसे रेल, Django, स्ट्रट्स आदि।

मॉडल दृश्य नियंत्रक

MVC वेब एप्लिकेशन विकसित करने के लिए एक सॉफ्टवेयर डिज़ाइन पैटर्न है। एक मॉडल व्यू कंट्रोलर पैटर्न तीन भागों से बना है -

Model - पैटर्न का निम्नतम स्तर डेटा को बनाए रखने के लिए जिम्मेदार है।
View - यह उपयोगकर्ता के लिए डेटा के सभी या एक हिस्से को प्रदर्शित करने के लिए जिम्मेदार है।
Controller - सॉफ्टवेयर कोड जो मॉडल और व्यू के बीच की बातचीत को नियंत्रित करता है।

MVC लोकप्रिय है क्योंकि यह उपयोगकर्ता इंटरफ़ेस परत से एप्लिकेशन लॉजिक को अलग करता है और चिंताओं को अलग करने का समर्थन करता है। यहां, नियंत्रक को आवेदन के लिए सभी अनुरोध प्राप्त होते हैं और फिर दृश्य द्वारा आवश्यक किसी भी डेटा को तैयार करने के लिए मॉडल के साथ काम करता है। दृश्य तब अंतिम प्रस्तुत करने योग्य प्रतिक्रिया उत्पन्न करने के लिए नियंत्रक द्वारा तैयार किए गए डेटा का उपयोग करता है। एमवीसी अमूर्त को रेखांकन के रूप में निम्न प्रकार से प्रस्तुत किया जा सकता है -

आदर्श

मॉडल एप्लिकेशन के डेटा के प्रबंधन के लिए जिम्मेदार है। यह दृश्य से अनुरोध का जवाब देता है और यह नियंत्रक से खुद को अपडेट करने के निर्देशों का भी जवाब देता है।

देखें

किसी विशेष प्रारूप में डेटा की प्रस्तुति, डेटा को प्रस्तुत करने के लिए एक नियंत्रक के निर्णय से शुरू होती है। वे स्क्रिप्ट आधारित टेम्प्लेटिंग सिस्टम हैं जिन्हें AJAX तकनीक के साथ एकीकृत करना बहुत आसान है।

नियंत्रक

नियंत्रक उपयोगकर्ता इनपुट का जवाब देने और डेटा मॉडल ऑब्जेक्ट पर इंटरैक्शन करने के लिए जिम्मेदार है। नियंत्रक इनपुट प्राप्त करता है, यह इनपुट को मान्य करता है और फिर डेटा मॉडल की स्थिति को संशोधित करने वाले व्यावसायिक संचालन को निष्पादित करता है।

TurboGears पुस्तकालयों और उपकरणों की एक संख्या के शीर्ष पर बनाया गया है। ये उपकरण TurboGears के विभिन्न संस्करणों के बीच बदल गए हैं। वर्तमान संस्करण के घटक (देखें 2.3.7) नीचे सूचीबद्ध हैं।

SQLAlchemy

यह एक खुला स्रोत एसक्यूएल किट है जो पायथन कोड के लिए ऑब्जेक्ट रिलेशन मैपिंग (ओआरएम) प्रदान करता है।

Genshi

इस अस्थायी इंजन का उपयोग टीजी अनुप्रयोगों के फ्रंट-एंड के निर्माण के लिए किया जाता है। गतिशील वेब पृष्ठों को प्रस्तुत करने के लिए एक वेब टेम्प्लेटिंग सिस्टम एक निश्चित डेटा स्रोत के साथ एक टेम्पलेट को जोड़ती है।

ToscaWidgets

यह सर्वर साइड कंट्रोल के साथ HTML फॉर्म जनरेट करने के लिए विजेट लाइब्रेरी है। Tosca जावास्क्रिप्ट विगेट्स और टूलकिट के साथ जुड़ने के लिए एक मिडलवेयर के रूप में भी कार्य करता है।

GearBox

यह परियोजनाओं और सर्वर TurboGears अनुप्रयोगों का प्रबंधन करने के लिए आदेशों का एक सेट प्रदान करता है। TurboGears अनुप्रयोगों को किसी भी WSGI अनुरूप वेब सर्वर पर तैनात किया जा सकता है।

वेब सर्वर गेटवे इंटरफेस (WSGI) को पायथन वेब एप्लिकेशन डेवलपमेंट के लिए एक मानक के रूप में अपनाया गया है। WSGI वेब सर्वर और वेब अनुप्रयोगों के बीच सार्वभौमिक इंटरफ़ेस के लिए एक विनिर्देश है। Wsgiref पैकेज WSGI का एक संदर्भ कार्यान्वयन है। इसका उपयोग WSGI समर्थन को वेब TurboGears वेब फ्रेमवर्क में जोड़ने के लिए किया जाता है। इस पैकेज में simple_server मॉड्यूल एक सरल HTTP सर्वर को लागू करता है जो WSGI अनुप्रयोगों को कार्य करता है। हम इस ट्यूटोरियल के दौरान विकसित अनुप्रयोगों का परीक्षण करने के लिए इसका उपयोग करेंगे।

शर्त

अजगर 2.6 या उच्चतर। पहले टर्बोबियर्स के संस्करण पाइथन 3. एक्स के अनुरूप नहीं थे। नवीनतम संस्करण पायथन 3. एक्स पर अच्छा काम करने का दावा करता है। हालांकि, टर्बोगियर्स का आधिकारिक प्रलेखन अभी भी पायथन 2.7 पर्यावरण पर आधारित है।

निम्नलिखित आदेश installs virtualenv -

pip install virtualenv

इस कमांड की जरूरत है administratorविशेषाधिकार। जोड़नाsudo before pipलिनक्स / मैक ओएस पर। यदि आप विंडोज पर हैं, तो प्रशासक के रूप में लॉग इन करें। Ubuntu virtualenv पर इसके पैकेज मैनेजर का उपयोग कर स्थापित किया जा सकता है।

Sudo apt-get install virtualenv

एक बार स्थापित होने के बाद, नया वर्चुअल वातावरण एक फ़ोल्डर में बनाया जाता है।

mkdir newproj
cd newproj
virtualenv venv

इसी वातावरण को सक्रिय करने के लिए, पर Linux/OS X

venv/bin/activate

पर Windows

venv\scripts\activate

हम अब तैयार हैं install TurboGearsइस माहौल में TurboGears की एक न्यूनतम स्थापना निम्नलिखित आदेश द्वारा की जाती है -

pip install TurboGears2

उपर्युक्त कमांड सिस्टम वाइड इंस्टॉलेशन के लिए वर्चुअल वातावरण के बिना सीधे चलाया जा सकता है।

विकास उपकरण के साथ टर्बोगियर्स स्थापित करने के लिए, निम्नलिखित कमांड का उपयोग करें -

pip install tg.devtools

TurboGears में एक न्यूनतम मोड है जो एकल फ़ाइल अनुप्रयोगों को जल्दी से बनाना संभव बनाता है। सरल उदाहरण और सेवाएं निर्भरता के न्यूनतम सेट के साथ जल्दी से बनाई जा सकती हैं।

एक टीजी आवेदन में आवेदन वर्ग से विरासत में मिला है TGControllerकक्षा। इस वर्ग की विधियाँ उपलब्ध हैं@expose से सजाने वाला tgमापांक। हमारे पहले आवेदन में,index()विधि हमारे आवेदन की जड़ के रूप में मैप की जाती है। TGController वर्ग को भी आयात करने की आवश्यकता हैtg मापांक।

from tg import expose, TGController
class MyController(TGController):
   @expose()
   def index(self):
      return 'Hello World turbogears'

अगला, एप्लिकेशन का कॉन्फ़िगरेशन सेट करें और एप्लिकेशन ऑब्जेक्ट घोषित करें। AppConfig यहाँ क्लास कंस्ट्रक्टर दो मापदंडों को लेता है - न्यूनतम विशेषता जो कि ट्रू और कंट्रोलर क्लास के लिए निर्धारित है।

config = AppConfig(minimal = True, root_controller = RootController())
application = config.make_wsgi_app()

make_wsgi_app() फ़ंक्शन यहां एप्लिकेशन ऑब्जेक्ट का निर्माण करता है।

इस एप्लिकेशन को परोसने के लिए, हमें अब HTTP सर्वर शुरू करने की आवश्यकता है। जैसा कि पहले उल्लेख किया गया है, हम उपयोग करेंगेsimple_server में मॉड्यूल wsgirefपैकेज की स्थापना और इसे शुरू करने के लिए। इस मॉड्यूल में हैmake_server() विधि जिसे पोर्ट नंबर और तर्क के रूप में एप्लिकेशन ऑब्जेक्ट की आवश्यकता होती है।

from wsgiref.simple_server import make_server
server = make_server('', 8080, application)
server.serve_forever()

इसका मतलब है कि हमारा आवेदन लोकलहोस्ट के पोर्ट नंबर 8080 में दिया जाएगा।

निम्नलिखित हमारे पहले TurboGears आवेदन का पूरा कोड है -

app.py

from wsgiref.simple_server import make_server
from tg import expose, TGController, AppConfig

class MyController(TGController):

   @expose()
   def index(self):
      return 'Hello World TurboGears'
		 
config = AppConfig(minimal = True, root_controller = MyController())
application = config.make_wsgi_app()

print "Serving on port 8080..."
server = make_server('', 8080, application)
server.serve_forever()

पायथन शेल से उपरोक्त स्क्रिप्ट चलाएँ।

Python app.py

दर्ज http://localhost:8080 'हैलो वर्ल्ड टर्बोजियर्स' संदेश देखने के लिए ब्राउज़र के एड्रेस बार में।

tg.devtoolsटर्बोगियर्स में गियरबॉक्स होता है। यह आदेशों का एक समूह है, जो अधिक जटिल टीजी परियोजनाओं के प्रबंधन के लिए उपयोगी हैं। फुल स्टैक प्रोजेक्ट्स को निम्नलिखित गियरबॉक्स कमांड द्वारा जल्दी से बनाया जा सकता है -

gearbox quickstart HelloWorld

इससे एक प्रोजेक्ट बनेगा जिसका नाम है HelloWorld।

एक TurboGears परियोजना में निम्नलिखित निर्देशिकाएं शामिल हैं -

Config - जहां प्रोजेक्ट सेटअप और कॉन्फ़िगरेशन निर्भर करता है
Controllers - सभी परियोजना नियंत्रक, वेब अनुप्रयोग का तर्क
i018n - समर्थित भाषाओं के लिए अनुवाद फाइलें
Lib - उपयोगिता अजगर कार्यों और कक्षाएं
Model - डेटाबेस
Public Static Files - सीएसएस, जावास्क्रिप्ट और छवियों
Templates - हमारे नियंत्रकों द्वारा उजागर किए गए टेम्प्लेट।
Tests - टेस्ट का सेट।
Websetup - आवेदन सेटअप में निष्पादित करने के लिए कार्य।

किसी प्रोजेक्ट को कैसे स्थापित करें

इस परियोजना को अब स्थापित करने की आवश्यकता है। एsetup.pyपरियोजना के आधार निर्देशिका में पहले से ही प्रदान किया गया है। यह स्क्रिप्ट निष्पादित होने पर प्रोजेक्ट निर्भरताएँ स्थापित हो जाती हैं।

Python setup.py develop

डिफ़ॉल्ट रूप से, निम्नलिखित आश्रितों को स्थापित परियोजना के समय स्थापित किया जाता है -

Beaker
Genshi
zope.sqlalchemy
sqlalchemy
alembic
repoze.who
tw2.forms
tgext.admin min 0.6.1
WebHelpers2
babel

स्थापना के बाद, शेल में निम्नलिखित आदेश जारी करके विकास सर्वर पर परियोजना की सेवा शुरू करें -

Gearbox serve –reload –debug

पूर्व-निर्मित उदाहरण परियोजना की सेवा के लिए उपर्युक्त आदेश का पालन करें। खुला हुआhttp://localhost:8080ब्राउजर में। यह रेडीमेड नमूना आवेदन खुद टर्बोबियर्स ढांचे के बारे में एक संक्षिप्त परिचय देता है।

इस हैलो प्रोजेक्ट में, कंट्रोलर डाइरेक्टरी में डिफॉल्ट कंट्रोलर बनाया जाता है Hello/hello/controllers.root.py। हमें करने दोmodify root.py निम्नलिखित कोड के साथ -

from hello.lib.base import BaseController
from tg import expose, flash

class RootController(BaseController):
   movie = MovieController()
   @expose()
   def index(self):
      return "<h1>Hello World</h1>"
		
   @expose()
   def _default(self, *args, **kw):
      return "This page is not ready"

एक बार काम करने की एक बुनियादी प्रक्रिया तैयार हो जाने के बाद, नियंत्रक वर्ग में अधिक विचार जोड़े जा सकते हैं। मेंMycontroller ऊपर कक्षा, एक नई विधि sayHello()जोड़ दिया गया है। @expose() डेकोरेटर अटैच करता है /sayHelloइसके लिए यूआरएल। यह फ़ंक्शन URL से पैरामीटर के रूप में एक नाम स्वीकार करने के लिए डिज़ाइन किया गया है।

'गियरबॉक्स सर्व' कमांड के माध्यम से सर्वर शुरू करने के बाद, http://localhost:8080। नमस्ते विश्व संदेश ब्राउज़र में प्रदर्शित किया जाएगा, भले ही निम्न URL दर्ज किए गए हों -

http://localhost:8080/

http://localhost:8080/index

इन सभी URL को मैप किया जाता है RootController.index()तरीका। इस वर्ग में भी है_default()जब भी किसी URL को किसी विशिष्ट फ़ंक्शन के लिए मैप नहीं किया जाता है, तो विधि को लागू किया जाएगा। URL की प्रतिक्रिया @expose () डेकोरेटर द्वारा फ़ंक्शन के लिए मैप की जाती है।

URL से एक उजागर फ़ंक्शन के लिए एक पैरामीटर भेजना संभव है। निम्न फ़ंक्शन URL से नाम पैरामीटर पढ़ता है।

@expose()
def sayHello(self, name):
   return '<h3>Hello %s</h3>' %name

निम्नलिखित आउटपुट ब्राउज़र में URL की प्रतिक्रिया के रूप में देखा जाएगा - http://localhost:8080/?name=MVL

Hello MVL

TurboGears तर्कों को कार्य करने के लिए स्वचालित रूप से URL मापदंडों को मैप करता है। हमारा रूटकंट्रोलर वर्ग बेसकंट्रोलर से विरासत में मिला है। इसे इस रूप में परिभाषित किया गया हैbase.py में lib folder आवेदन का।

इसका कोड इस प्रकार है -

from tg import TGController, tmpl_context
from tg import request

__all__ = ['BaseController']

def __call__(self, environ, context):
   tmpl_context.identity = request.identity
   return TGController.__call__(self, environ, context)

TGController.__call__ अनुरोध विधि के लिए नियंत्रक विधि को प्रेषित किया जाता है।

एक ईवेंट हालांकि HTML सामग्री को ब्राउज़र में लौटाया जा सकता है, अधिक उन्नत आउटपुट के लिए, टेम्पलेट इंजन का उपयोग हमेशा पसंद किया जाता है। गियरबॉक्स द्वारा पूर्ण स्टैक प्रोजेक्ट 'क्विकस्टार्टेड' में, Genshi को डिफ़ॉल्ट टेम्पलेट रेंडरर के रूप में सक्षम किया गया है। एक न्यूनतम आवेदन में, हालांकि गेन्शी (या किसी अन्य टेम्पलेट इंजन, जैसे कि जिंजा) को स्थापित करने और सक्षम करने की आवश्यकता है। जेनशी टेम्प्लेट इंजन शुद्ध एक्सएचटीएमएल में टेम्प्लेट लिखने की अनुमति देता है और उन्हें संकलन समय पर मुद्दों का पता लगाने और टूटे हुए पृष्ठों की सेवा को रोकने के लिए मान्य करता है।

डॉटेड नोटेशन का उपयोग करके टेम्पलेट्स को संदर्भित किया जाता है। हमारे हैलो प्रोजेक्ट में टेम्प्लेट वेब पेज को स्टोर करने के लिए एक टेम्प्लेट डायरेक्टरी दी गई है। इसलियेsample.html के रूप में संदर्भित किया जाएगा hello.templates.sample(विस्तार का उल्लेख नहीं)। TurboGears द्वारा इस टेम्पलेट को एक एक्सपोजर डेकोरेटर के माध्यम से इसके द्वारा नियंत्रक विधि को जोड़ने के लिए प्रदान करता हैtg.render_template() समारोह।

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

शुरुआत करने के लिए, आइए हम सादे html स्क्रिप्ट के साथ एक वेब पेज प्रदर्शित करें। उजागर नियंत्रक एnull dictionary object जैसा कि हम HTML स्क्रिप्ट के अंदर पार्स होने के लिए कोई डेटा भेजने का इरादा नहीं रखते हैं।

कैसे एक नमूना HTML बनाने के लिए

हमारी sample.htmlनीचे दिया गया है। सुनिश्चित करें कि यह प्रोजेक्ट की टेम्प्लेट डायरेक्टरी में संग्रहीत है।

<html>
   <head>
      <title>TurboGears Templating Example</title>
   </head>
	
   <body>
      <h2>Hello, Welcome to TurboGears!.</h2>
   </body>
</html>

जोड़ना sample() में कार्य करते हैं root.py और इसके माध्यम से sample.html को उजागर करें।

@expose("hello.templates.sample")
   def sample(self):
      return {}

URL के बाद ब्राउज़र में निम्न परिणाम प्रदर्शित किया जाएगा http://localhost:8080/sample वेब सर्वर शुरू करने के बाद दर्ज किया जाता है।

जैसा कि ऊपर उल्लेख किया गया है, एक शब्दकोश वस्तु को एक Genshi टेम्पलेट के मापदंडों के संग्रह के रूप में भेजा जाता है। इस टेम्प्लेट में 'प्लेस होल्डर्स' होते हैं, जो नियंत्रक से प्राप्त मापदंडों से गतिशील रूप से भरे होते हैं।

हमें बदलने दो sample() नमूना टेम्पलेट में एक शब्दकोश वस्तु भेजने के लिए कार्य करते हैं।

@expose("hello.templates.sample")
   def sample(self,name):
      mydata = {'person':name}
      return mydata

सृजन करना sample.html टेम्पलेट फ़ोल्डर में (templates\sample.html)

<html>
   <head>
      <title>TurboGears Templating Example</title>
   </head>
	
   <body>
      <h2>Hello, my name is ${person}!.</h2>
   </body>
</html>

उपरोक्त HTML कोड में, ${person}प्लेसहोल्डर है। दर्जhttp://localhost:8080/sample?name=MVLब्राउज़र में URL के रूप में। इस URL को मैप किया गया हैsample()हमारे रूट कंट्रोलर में विधि। यह एक शब्दकोश वस्तु देता है। इसे टेम्प्लेट डायरेक्टरी में लिंक्ड टेंप्लेट पेज नमूना.html द्वारा उठाया गया है। $ {व्यक्ति} को तब वेब पेज में MVL द्वारा प्रतिस्थापित किया जाता है।

एक नियंत्रक फ़ंक्शन में HTML फॉर्म डेटा तक पहुंचना भी संभव है। HTML फॉर्म फॉर्म डेटा भेजने के लिए उपयोग करता है।

एचटीपी प्रोटोकॉल विश्वव्यापी वेब में डेटा संचार की नींव है। निर्दिष्ट URL से डेटा पुनर्प्राप्ति के विभिन्न तरीकों को इस प्रोटोकॉल में परिभाषित किया गया है। निम्नलिखित तालिका विभिन्न http विधियों का सारांश प्रस्तुत करती है -

अनु क्रमांक।	HTTP तरीके और विवरण
1	GET सर्वर को अनएन्क्रिप्टेड रूप में डेटा भेजता है। सबसे आम तरीका।
2	HEAD GET के समान है, लेकिन प्रतिक्रिया निकाय के बिना
3	POST HTML फॉर्म डेटा को सर्वर पर भेजने के लिए उपयोग किया जाता है। POST विधि द्वारा प्राप्त डेटा सर्वर द्वारा कैश नहीं किया जाता है।
4	PUT अपलोड की गई सामग्री के साथ लक्ष्य संसाधन के सभी वर्तमान अभ्यावेदन को प्रतिस्थापित करता है।
5	DELETE किसी URL द्वारा दिए गए लक्ष्य संसाधन के सभी वर्तमान अभ्यावेदन को हटा देता है

HTML फॉर्म बनाना

आइए हम एक HTML फॉर्म बनाते हैं और एक URL पर फ़ॉर्म डेटा भेजते हैं। निम्न स्क्रिप्ट को login.html के रूप में सहेजें

<html>
   <body>
      <form action = "http://localhost:8080/login" method = "get">
         <p>Enter Name:</p>
         <p><input type = "text" name = "nm" /></p>
         <p><input type = "submit" value = "submit" /></p>
      </form>
   </body>
</html>

इस फॉर्म में दर्ज डाटा को सबमिट किया जाना है ‘/login’ URL। अब एक कंट्रोलर फंक्शन बनाएंloginpage() और ऊपर दिए गए html पेज को उजागर करें।

@expose("hello.templates.login")
   def loginpage(self):
      return {}

प्रपत्र डेटा प्राप्त करने के लिए, एक प्रदान करें login()नियंत्रक, जिसके रूप में विशेषताएँ इसके पैरामीटर हैं। यहाँ‘nm’ लॉगिन फॉर्म में टेक्स्ट इनपुट फील्ड का नाम है, इसे लॉगिन () फ़ंक्शन के पैरामीटर के रूप में उपयोग किया जाता है।

@expose("hello.templates.sample")
   def login(self, nm):
      name = nm
      return {'person':name}

जैसा कि देखा जा सकता है, लॉगिन फॉर्म से प्राप्त डेटा को नमूना.html टेम्पलेट (पहले इस्तेमाल किया गया) में भेजा जा रहा है। यह एक द्वारा पार्स हैGenshi template engine निम्नलिखित उत्पादन उत्पन्न करने के लिए -

पोस्ट विधि

जब HTML फॉर्म एक्शन विशेषता में URL को डेटा भेजने के लिए POST विधि का उपयोग करता है, तो फॉर्म डेटा URL में उजागर नहीं होता है। एन्कोडेड डेटा एक में प्राप्त होता हैdictनियंत्रक फ़ंक्शन द्वारा तर्क। **kw नीचे तर्क डेटा के लिए शब्दकोष धारण है।

HTML फॉर्म में दो इनपुट टेक्स्ट फील्ड होते हैं।

<html>
   <body>
	
      <form action = "http://localhost:8080/marks" method = "post">
         <p>Marks in Physics:</p>
         <p><input type = "text" name = "phy" /></p>
         <p>Marks in Maths:</p>
         <p><input type = "text" name = "maths" /></p>
         <p><input type = "submit" value = "submit" /></p>
      </form>
		
   </body>	
</html>

marks() नियंत्रक प्रपत्र डेटा प्राप्त करता है और इसे भेजता है sample.htmlटेम्पलेट। के लिए कोडroot.py इस प्रकार है -

from hello.lib.base import BaseController
from tg import expose, request

class RootController(BaseController):
   @expose("hello.templates.marks")
   def marksform(self):
      return {}
		
   @expose("hello.templates.sample")
   def marks(self, **kw):
      phy = kw['phy']
      maths = kw['maths']
      ttl = int(phy)+int(maths)
      mydata = {'phy':phy, 'maths':maths, 'total':ttl}
      return mydata

अंत में, sample.html टेम्पलेट निम्नानुसार है -

<html>
   <head>
      <title>TurboGears Templating Example</title>
   </head>
	
   <body>
      <h2>Hello, Welcome to TurboGears!.</h2>
      <h3>Marks in Physics: ${phy}.</h3>
      <h3>Marks in Maths: ${maths}.</h3> <h3>Total Marks: ${total}</h3>
   </body>
	
</html>

सर्वर प्रारंभ करें (यदि पहले से नहीं चल रहा है)

Gearbox server –reload –debug

दर्ज http://localhost::8080/marksform ब्राउजर में

sample.html निम्नलिखित उत्पादन प्रस्तुत करना होगा -

Genshi एक XML आधारित टेम्पलेट भाषा है। यह समान हैKid, जो टर्बोगियर्स के पुराने संस्करणों के लिए टेम्पलेट इंजन हुआ करता था। गेन्शी के साथ-साथ किड अन्य प्रसिद्ध टेम्प्लेट भाषाओं जैसे से प्रेरित हैंHSLT, TAL तथा PHP।

एक Genshi टेम्पलेट में प्रसंस्करण निर्देश होते हैं। ये निर्देश एक टेम्पलेट में तत्व और विशेषताएं हैं। गनेशी निर्देशों को एक नाम स्थान में परिभाषित किया गया हैhttp://genshi.edgewall.org/। इसलिए इस नाम स्थान को टेम्पलेट के मूल तत्व में घोषित किया जाना चाहिए।

<html xmlns = "http://www.w3.org/1999/xhtml"
   xmlns:py = "http://genshi.edgewall.org/"
   lang = "en">
...
</html>

उपरोक्त घोषणा का अर्थ है कि डिफ़ॉल्ट नाम स्थान XHTML पर सेट है और गेन्शी निर्देशों में 'py' उपसर्ग है।

गनेशी के निर्देश

गेन्शी में कई निर्देशों को परिभाषित किया गया है। निम्नलिखित सूची गनेशी के निर्देशों की गणना करती है -

py:if
py:choose
py:for
py:def
py:match
py:with
py:replace
py:content
py:attrs
py:strip

सशर्त खंड

Genshi, सामग्री py के सशर्त प्रतिपादन के लिए दो निर्देश प्रदान करता है: if और py: choose।

py: अगर

इस निर्देश के तत्व की सामग्री को केवल तभी प्रस्तुत किया जाएगा जब अभिव्यक्ति में if clauseसत्य का मूल्यांकन करता है। मान लें कि टेम्पलेट संदर्भ में डेटा है{‘foo’:True, ‘bar’:’Hello’}, निम्नलिखित निर्देश -

<div>
   <b py:if = "foo">${bar}</b>
</div>

में परिणाम होगा

Hello

यह आउटपुट, हालांकि प्रदान नहीं किया जाएगा ‘foo’ is set to False।

इस निर्देश का उपयोग तत्व के रूप में भी किया जा सकता है। इस मामले में<py:if> द्वारा बंद किया जाना चाहिए </py:if>

<div>
   <py:if test = "foo">
      <b>${bar}</b>
   </py:if>
</div>

py: चुनें

के उपयोग से उन्नत सशर्त प्रसंस्करण संभव है py:choose के साथ सम्मिलन में py:when तथा py:otherwiseनिर्देशों। यह सुविधा के समान हैswitch – case में निर्माण C/C++।

में अभिव्यक्ति py:choose निर्देश की पहचान विभिन्न मूल्यों के साथ की जाती है py:whenविकल्प और संबंधित सामग्री प्रदान की जाएगी। के रूप में एक डिफ़ॉल्ट विकल्प प्रदान किया जा सकता हैpy:otherwise निर्देश।

<div py:choose = "foo”>
   <span py:when = "0">0</span>
   <span py:when = "1">1</span>
   <span py:otherwise = "">2</span>
</div>

निम्नलिखित उदाहरण के उपयोग को दर्शाता है py:choose तथा py:whenनिर्देशों। एचटीएमएल फॉर्म URL / / के लिए डेटा पोस्ट करता है। marks() फ़ंक्शन पुनर्निर्देश करता है और एक शब्दकोश वस्तु के रूप में निशान को परिणाम देता है total.htmlटेम्पलेट। का सशर्त प्रदर्शनresult Pass/Fail का उपयोग करके प्राप्त किया जाता है py:choose तथा py:when निर्देशों।

प्रवेश करने का एचटीएमएल स्क्रिप्ट (marks.html) इस प्रकार है -

<html>
   <body>
      <form action = "http://localhost:8080/marks" method = "post">
         <p>Marks in Physics:</p>
         <p><input type = "text" name = "phy" /></p>
         <p>Marks in Maths:</p>
         <p><input type = "text" name = "maths" /></p>
         <p><input type = "submit" value = "submit" /></p>
      </form>
   </body>
</html>

का पूरा कोड root.pyइस प्रकार है। marks() नियंत्रक अंक और परिणाम भेज रहा है total.html टेम्पलेट -

from hello.lib.base import BaseController
from tg import expose, request

class RootController(BaseController):
   @expose("hello.templates.marks")
      def marksform(self):
      return {}
		
   @expose("hello.templates.total")
      def marks(self, **kw):
      phy = kw['phy']
      maths = kw['maths']
      ttl = int(phy)+int(maths)
      avg = ttl/2
		
      if avg ≥ 50:
         mydata = {'phy':phy, 'maths':maths, 'total':ttl, 'result':2}
      else:
         mydata = {'phy':phy, 'maths':maths, 'total':ttl,'result':1}
	
      return mydata

total.html टेम्पलेट फ़ोल्डर में डिक्शनरी डेटा प्राप्त होता है और इसे html आउटपुट में सशर्त रूप से निम्न प्रकार से प्राप्त करता है -

<html xmlns = "http://www.w3.org/1999/xhtml"
   xmlns:py = "http://genshi.edgewall.org/"
   lang = "en">
	
   <head>
      <title>TurboGears Templating Example</title>
   </head>
	
   <body>
      <h2>Hello, Welcome to TurboGears!.</h2>
      <h3>Marks in Physics: ${phy}.</h3> <h3>Marks in Maths: ${maths}.</h3>
      <h3>Total Marks: ${total}</h3>
		
      <div py:choose = "result">
         <span py:when = "1"><h2>Result: Fail</h2></span>
         <span py:when = "2"><h2>Result: Pass</h2></span>
      </div>
		
   </body>
</html>

सर्वर प्रारंभ करें (यदि पहले से नहीं चल रहा है)

Gearbox server –reload –debug

दर्ज http://localhost::8080/marksform ब्राउज़र में -

total.html निम्नलिखित उत्पादन प्रस्तुत करना होगा -

py: के लिए

पीआई में तत्व: निर्देश के लिए एक पुनरावृत्त में प्रत्येक आइटम के लिए दोहराया जाता है, आमतौर पर पायथन सूची ऑब्जेक्ट। अगरitems = [1,2,3] एक टेम्प्लेट के संदर्भ में मौजूद है, इसे py को फॉलो करके पुनरावृत्त किया जा सकता है: निर्देश के लिए -

<ul>
   <li py:for = "item in items">${item}</li>
</ul>

निम्नलिखित आउटपुट प्रदान किया जाएगा -

1
2
3

निम्न उदाहरण से पता चलता है कि HTML फ़ॉर्म डेटा कुल पृष्ठ में प्रदान किया गया है। py का उपयोग करके टेम्पलेट: निर्देश के लिए भी निम्नानुसार इस्तेमाल किया जा सकता है -

<py:for each = "item in items">
   <li>${item}</li>
</py:for>

HTML फॉर्म स्क्रिप्ट

<html>
   <body>
	
      <form action = "http://localhost:8080/loop" method="post">
         <p>Marks in Physics:</p>
         <p><input type = "text" name = "phy" /></p>
         <p>Marks in Chemistry:</p>
         <p><input type = "text" name = "che" /></p>
         <p>Marks in Maths:</p>
         <p><input type = "text" name = "maths" /></p>
         <p><input type = "submit" value = "submit" /></p>
      </form>
		
   </body>
</html>

loop() कंट्रोलर फॉर्म डेटा को पढ़ता है और सूची ऑब्जेक्ट के रूप में total.template पर भेजता है।

from hello.lib.base import BaseController
from tg import expose, request

class RootController(BaseController):
   @expose("hello.templates.marks")
   def marksform(self):
   return {}
	
   @expose("hello.templates.temp")
   def loop(self, **kw):
      phy = kw['phy']
      maths = kw['maths']
      che = kw['che']
      l1 = []
      l1.append(phy)
      l1.append(che)
      l1.append(maths)
		
   return ({'subjects':['physics', 'Chemistry', 'Mathematics'], 'marks':l1})

Temp.html टेम्पलेट py का उपयोग करता है: एक मेज के रूप में तानाशाह वस्तु की सामग्री को प्रस्तुत करने के लिए लूप के लिए।

<html xmlns = "http://www.w3.org/1999/xhtml" 
   xmlns:py = "http://genshi.edgewall.org/" lang = "en">
	
   <body>
      <b>Marks Statement</b>
      <table border = '1'>
         <thead>
            <py:for each = "key in subjects"><th>${key}</th></py:for>
         </thead>
         <tr>
            <py:for each = "key in marks"><td>${key}</td></py:for>
         </tr>
      </table>
   </body>
</html>

सर्वर प्रारंभ करें (यदि पहले से नहीं चल रहा है)

gearbox server –reload –debug

दर्ज http://localhost::8080/marksform ब्राउज़र में।

उपरोक्त प्रपत्र प्रस्तुत किए जाने पर निम्न आउटपुट ब्राउज़र में प्रदर्शित किया जाएगा।

py: डीईएफ़

इस निर्देश का उपयोग मैक्रो बनाने के लिए किया जाता है। एक मैक्रो टेम्पलेट कोड का पुन: प्रयोज्य स्निपेट है। पायथन फ़ंक्शन की तरह, इसका एक नाम है और वैकल्पिक रूप से पैरामीटर हो सकते हैं। इस मैक्रो का आउटपुट किसी भी स्थान पर टेम्पलेट में डाला जा सकता है।

Py: def निर्देश निम्नलिखित सिंटैक्स का अनुसरण करता है -

<p py:def = "greeting(name)">
   Hello, ${name}!
</p>

इस मैक्रो को 'नाम' पैरामीटर के लिए एक चर मान के साथ प्रदान किया जा सकता है।

${greeting('world')} ${greeting('everybody)}

इस निर्देश का सिंटैक्स के एक अन्य संस्करण के साथ भी उपयोग किया जा सकता है -

<py:def function = "greeting(name)">
   <p>Hello, ${name}! </p>
</py:def>

निम्नलिखित उदाहरण में, macro() में नियंत्रक root.py भेजता है dict दो कुंजी name1 और name2 से मैक्रो.html टेम्पलेट के साथ ऑब्जेक्ट।

from hello.lib.base import BaseController
from tg import expose, request

class RootController(BaseController):
   @expose('hello.templates.macro')
   def macro(self):
      return {'name1':'TutorialPoint', 'name2':'TurboGears'}

इस मैक्रो.html टेम्प्लेट में ग्रीटिंग नामक एक मैक्रो की परिभाषा है। इसका उपयोग नियंत्रक से प्राप्त डेटा के लिए शुभकामना संदेश उत्पन्न करने के लिए किया जाता है।

<html xmlns = "http://www.w3.org/1999/xhtml"
   xmlns:py = "http://genshi.edgewall.org/"
   lang = "en">
	
   <body>
      <h2>py:def example</h2>
		
      <div>
         <div py:def = "greeting(name)">
            Hello, Welcome to ${name}!
         </div>
				
         <b>
            ${greeting(name1)} ${greeting(name2)}
         </b>
			
      </div>
   </body>
</html>

गियरबॉक्स का उपयोग करके सर्वर शुरू करें

gearbox serve –reload –debug

ब्राउज़र में निम्न URL दर्ज करके मैक्रो () कंट्रोलर इंक्वायरी करें -

http://localhost:8080/macro

ब्राउज़र में निम्नलिखित आउटपुट प्रस्तुत किए जाएंगे -

py: के साथ

यह निर्देश आपको स्थानीय चर में अभिव्यक्ति प्रदान करने देता है। ये स्थानीय चर कम क्रिया के अंदर अभिव्यक्ति और अधिक कुशल बनाते हैं।

मान लें कि x = 50 एक टेम्प्लेट के लिए संदर्भ डेटा में दिया गया है, तो निम्नलिखित होगा: py: निर्देश के साथ -

<div>
   <span py:with = "y = 50; z = x+y">$x $y $z</span>
</div>

इसका परिणाम निम्न आउटपुट में होगा -

50 50 100

पी के लिए एक वैकल्पिक संस्करण: निर्देश के साथ भी उपलब्ध है -

<div>
   <py:with = "y = 50; z = x+y">$x $y $z</py:with>
</div>

निम्नलिखित उदाहरण में, मैक्रो () नियंत्रक नाम, phy और गणित कुंजियों के साथ एक तानाशाह वस्तु लौटाता है।

from hello.lib.base import BaseController
from tg import expose, request

class RootController(BaseController):
   @expose('hello.templates.macro')
   def macro(self):
      return {'name':'XYZ', 'phy':60, 'maths':70}

टेम्पलेट मैक्रो.html py का उपयोग करके phy और maths कुंजियों के मान जोड़ता है: निर्देश के साथ।

<html xmlns = "http://www.w3.org/1999/xhtml"
   xmlns:py = "http://genshi.edgewall.org/"
   lang = "en">
	
   <body>
      <h2>py:with example</h2>
      <h3>Marks Statement for : ${name}!</h3> <b>Phy: $phy Maths: $maths <span py:with = "ttl = phy+maths">Total: $ttl</span>
      </b>
		
   </body>
	
</html>

ब्राउज़र URL के जवाब में निम्न आउटपुट प्रस्तुत करेगा http://localhost:8080/macro

संरचना हेरफेर निर्देश

py:attrs निर्देश तत्व से विशेषताओं को जोड़ता है, संशोधित करता है या हटाता है।

<ul>
   <li py:attrs = "foo">Bar</li>
</ul>

अगर foo = {‘class’:’collapse’} एक टेम्पलेट संदर्भ में मौजूद है, जिसे उपरोक्त स्निपेट प्रस्तुत करेगा।

<ul>
   <li class = "collapse">Bar</li>
</ul>

py:content निर्देश अभिव्यक्ति के मूल्यांकन के परिणाम के साथ किसी भी नेस्टेड सामग्री को बदल देता है -

<ul>
   <li py:content = "bar">Hello</li>
</ul>

संदर्भ डेटा में बार = 'बाय' को देखते हुए, यह उत्पादन करेगा

<ul>
   <li>Bye</li>
</ul>

py:replace निर्देश अभिव्यक्ति के मूल्यांकन के परिणाम के साथ तत्व को स्वयं प्रतिस्थापित करता है -

<div>
   <span py:replace = "bar">Hello</span>
</div>

संदर्भ डेटा में बार = 'बाय' को देखते हुए, यह उत्पादन करेगा

<div>
   Bye
</div>

किसी अन्य XML दस्तावेज़ (विशेष रूप से HTML दस्तावेज़) की सामग्री को वर्तमान दस्तावेज़ में समावेश टैग का उपयोग करके शामिल किया जा सकता है। इस तरह के समावेशन को सक्षम करने के लिए, HTML दस्तावेज़ के मूल तत्व में XInclude नेमस्पेस घोषित किया जाना चाहिए।

<html xmlns = "http://www.w3.org/1999/xhtml" xmlns:xi = "http://www.w3.org/2001/XInclude >

उपरोक्त घोषणा निर्दिष्ट करती है जिसमें निर्देश शामिल हैं ‘xi’उपसर्ग। वर्तमान दस्तावेज़ में एक और HTML पृष्ठ की सामग्री जोड़ने के लिए, xi का उपयोग करें: निम्नानुसार निर्देश शामिल करें -

<xi:include href = "somepage.html" />

निम्नलिखित उदाहरण में, root.py शामिल हैं () नियंत्रक, जो exp.html शामिल हैं।

from hello.lib.base import BaseController
from tg import expose, request

class RootController(BaseController):
   @expose('hello.templates.include')
   def include(self):
      return {}

शीर्षक और पाद HTML

शामिल.html में, नाम स्थान घोषित किया गया है और शीर्ष लेख की सामग्री शामिल है। यहां HTML स्क्रिप्ट की टेम्प्लेट \ _.html शामिल है -

<html xmlns = "http://www.w3.org/1999/xhtml" 
   xmlns:xi = "http://www.w3.org/2001/XInclude">
	
   <head>
      <title>TurboGears Templating Example</title>
   </head>
	
   <body>
      <xi:include href = "heading.html" />
      <h2>main content </h2>
      <xi:include href = "footer.html" />
   </body>
	
</html>

यहां टेम्प्लेट्स \ Heading.html कोड है -

<html>
   <head>
      <title>TurboGears Templating Example</title>
   </head>
	
   <body>
      <h1>This is page Header</h1>
   </body>
</html>

निम्न टेम्पलेट \ footer.html है

<html>
   <head>
      <title>TurboGears Templating Example</title>
   </head>
	
   <body>
      <h3>This is page footer</h3>
   </body>
</html>

गियरबॉक्स का उपयोग करके विकास शुरू करें और दर्ज करें http://localhost:8080/includeब्राउज़र में। प्रस्तुत आउटपुट को नीचे दिखाया गया है -

इस तरह विचारों के मॉड्यूलर निर्माण को प्राप्त किया जा सकता है। यदि xi में उल्लिखित संसाधन: निर्देश शामिल नहीं है, तो एक त्रुटि उठाई जाएगी। ऐसी स्थिति में एक वैकल्पिक संसाधन को xi: fallback का उपयोग करके लोड किया जा सकता है।

<xi:include href = “main.html”>
   <xi:fallback href = ”default.html”/>
</xi.include>

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

Root.py में निम्नलिखित नियंत्रक जोड़ें।

@expose('hello.templates.ref-include')
   def refinclude(self):
      return {'pages':['heading','main','footer']}

टेम्पलेट फ़ोल्डर में Ref-शामिल.html के रूप में निम्नलिखित कोड को सहेजें।

<html xmlns = "http://www.w3.org/1999/xhtml"
   xmlns:py = "http://genshi.edgewall.org/"
   xmlns:xi = "http://www.w3.org/2001/XInclude">
	
   <head>
      <title>TurboGears Templating Example</title>
   </head>
	
   <body>
      <xi:include href = "${name}.html" py:for = "name in pages" />
   </body>
	
</html>

सर्वर शुरू करने से पहले यह सुनिश्चित कर लें कि टेम्प्लेट फ़ोल्डर में एक शीर्ष लेख। html, main.html और footer.html है। दर्जhttp://localhost:8082/refinclude निम्न आउटपुट प्राप्त करने के लिए ब्राउज़र में

@expose()डिफ़ॉल्ट रूप से डेकोरेटर html सामग्री प्रदान करता है। हालाँकि, इसे सेट किया जा सकता हैjson content type। TurboGears के माध्यम से json प्रतिपादन का समर्थन करता हैtg.jsonify.JSONEncoder (**kwargs)कक्षा। Json डेटा रेंडर करने के लिए डेकोरेटर को एक्सपोज़ करने के लिए बस कंटेंट टाइप के रूप में json पास करें।

@expose('json')
def jsondata(self, **kwargs):
   return dict(hello = 'World')

यदि ब्राउज़र में '/ jsondata' URL दर्ज किया गया है, तो यह प्रदर्शित करके जवाब देगा -

{"hello": "World"}

jsonp रेंडरिंग

jsonp पैडिंग के साथ json के लिए खड़ा है। यह जेनसन आउटपुट के समान काम करता है सिवाय इस तथ्य के कि यह एक एप्लिकेशन / जावास्क्रिप्ट प्रतिक्रिया को एक कॉल के साथ एक जावास्क्रिप्ट फ़ंक्शन को प्रदान करता है जो नियंत्रक द्वारा दिए गए सभी मानों को फ़ंक्शन तर्क के रूप में प्रदान करता है।

Jsonp रेंडरिंग को सक्षम करने के लिए आपको पहले इसे अपने एप्लिकेशन के अंदर आवश्यक इंजनों की सूची में जोड़ना होगा - config/app_cfg.py -

base_config.renderers.append('jsonp')

अपने एक्सपोज डेकोरेटर को इस प्रकार लिखें -

@expose('json')
@expose('jsonp')
def jsonpdata (self, **kwargs): 
   return dict(hello = 'World')

जब पहुँच / jsonpdata? कॉलबैक = कॉलमे, आपको देखना चाहिए -

callme({"hello": "World"});

कभी-कभी, एक वेब एप्लिकेशन को एक URL संरचना की आवश्यकता हो सकती है जो एक से अधिक स्तर की हो। TurboGears ऑब्जेक्ट पदानुक्रम को उचित विधि खोजने के लिए पार कर सकता है जो आपके अनुरोध को संभाल सकता है।

गियरबॉक्स के साथ एक प्रोजेक्ट 'क्विकस्टार्टेड' में प्रोजेक्ट के लिब फोल्डर में बेसकंट्रोलर क्लास है। यह 'हेलो / हैलो / लीब / बेसड्रोमा' के रूप में उपलब्ध है। यह सभी उप नियंत्रकों के लिए आधार वर्ग के रूप में कार्य करता है। आवेदन में URL के एक उप-स्तर को जोड़ने के लिए, BaseController से व्युत्पन्न BlogController नामक एक उप वर्ग डिज़ाइन करें।

इस BlogController में दो नियंत्रक कार्य, सूचकांक () और पोस्ट () हैं। दोनों को एक-एक टेम्पलेट, blog.html और post.html को उजागर करने के लिए डिज़ाइन किया गया है।

Note - ये टेम्प्लेट एक सब फोल्डर के अंदर डाले जाते हैं - टेम्प्लेट / ब्लॉग

class BlogController(BaseController):

   @expose('hello.templates.blog.blog')
   def index(self):
      return {}
		
   @expose('hello.templates.blog.post')
   def post(self):
      from datetime import date
      now = date.today().strftime("%d-%m-%y")
      return {'date':now}

अब RootController class (root.py) में इस वर्ग की एक वस्तु घोषित करें -

class RootController(BaseController):
   blog = BlogController()

शीर्ष स्तर के URL के लिए अन्य नियंत्रक कार्य इस कक्षा में पहले की तरह होंगे।

जब एक यू.आर.एल. http://localhost:8080/blog/दर्ज किया गया है, इसे BlogController क्लास के अंदर इंडेक्स () कंट्रोलर फंक्शन में मैप किया जाएगा। इसी तरह,http://localhost:8080/blog/post पोस्ट () फ़ंक्शन को लागू करेगा।

Blog.html और post.html का कोड इस प्रकार है -

Blog.html

<html>
   <body>
      <h2>My Blog</h2>
   </body>
</html>

post.html

<html>
   <body>
      <h2>My new post dated $date</h2>
   </body>
</html>

जब एक यू.आर.एल. http://localhost:8080/blog/ दर्ज किया गया है, यह निम्नलिखित उत्पादन का उत्पादन करेगा -

जब एक यू.आर.एल. http://localhost:8080/blog/post दर्ज किया गया है, यह निम्नलिखित उत्पादन का उत्पादन करेगा -

किसी भी वेब एप्लिकेशन का सबसे आवश्यक पहलू उपयोगकर्ता के लिए यूजर इंटरफेस प्रस्तुत करना है। HTML एक <form> टैग प्रदान करता है जिसका उपयोग इंटरफ़ेस डिजाइन करने के लिए किया जाता है। फॉर्म के तत्व जैसे टेक्स्ट इनपुट, रेडियो, चयन आदि का उचित उपयोग किया जा सकता है। उपयोगकर्ता द्वारा दर्ज किया गया डेटा GET या POST विधि द्वारा सर्वर साइड स्क्रिप्ट को Http अनुरोध संदेश के रूप में प्रस्तुत किया जाता है।

सर्वर साइड स्क्रिप्ट को http अनुरोध डेटा से फार्म तत्वों को फिर से बनाना है। तो इस आशय में, प्रपत्र तत्वों को दो बार परिभाषित किया जाना है - एक बार HTML में और फिर से सर्वर साइड स्क्रिप्ट में।

HTML फॉर्म का उपयोग करने का एक और नुकसान यह है कि फॉर्म के तत्वों को गतिशील रूप से प्रस्तुत करना कठिन (यदि असंभव नहीं है)। HTML स्वयं उपयोगकर्ता के इनपुट को मान्य करने का कोई तरीका नहीं प्रदान करता है।

ToscaWidgets2

TurboGears ToscaWidgets2 पर निर्भर करता है, एक लचीला रूप प्रतिपादन और सत्यापन पुस्तकालय। ToscaWidgets का उपयोग करके, हम अपनी पायथन स्क्रिप्ट में फ़ॉर्म फ़ील्ड को परिभाषित कर सकते हैं और HTML टेम्पलेट का उपयोग करके उन्हें प्रस्तुत कर सकते हैं। सत्यापन को ट्व 2 क्षेत्र में लागू करना भी संभव है।

ToscaWidgets लाइब्रेरी कई मॉड्यूल का एक संग्रह है। कुछ महत्वपूर्ण मॉड्यूल नीचे सूचीबद्ध हैं -

tw2.core- यह कोर कार्यक्षमता प्रदान करता है। इस मॉड्यूल में विजेट एंड-यूज़र के लिए उपलब्ध नहीं हैं।
tw2.forms- यह एक बेसिक फॉर्म लाइब्रेरी है। इसमें फ़ील्ड्स, फ़ील्ड्स और फ़ार्म के लिए विजेट्स शामिल हैं।
tw2.dynforms - इसमें डायनामिक रूप कार्यक्षमता शामिल है।
tw2.sqla - यह SQLAlchemy डेटाबेस के लिए एक इंटरफ़ेस है।

tw2.forms

इसमें एक फॉर्म क्लास होता है, जो कस्टम फॉर्म के लिए आधार का काम करता है। वहाँ एक TableForm वर्ग है जो दो स्तंभ तालिका में फ़ील्ड प्रदान करने में उपयोगी है। ListForm अपने क्षेत्रों को एक अव्यवस्थित सूची में प्रस्तुत करता है।

निम्न तालिका tw2.forms मॉड्यूल में सबसे अधिक इस्तेमाल किए जाने वाले प्रकारों के क्षेत्रों को दिखाती है -

अनु क्रमांक।	फ़ील्ड और विवरण
1	TextField एक एकल पंक्ति पाठ इनपुट फ़ील्ड
2	TextArea मल्टी-लाइन टेक्स्ट इनपुट फ़ील्ड
3	CheckBox लेबल के साथ एक जाँच योग्य आयताकार बॉक्स प्रस्तुत करता है
4	CheckBoxList बहु-चयन समूह pf चेक बॉक्स
5	RadioButton चयन / अचयनित करने के लिए एक टॉगल बटन
6	RadioButtonList परस्पर अनन्य रेडियो बटन का समूह
7	PasswordField टेक्स्टफील्ड के समान लेकिन इनपुट कुंजियों का पता नहीं चलता है
8	CalendarDatePicker एक तिथि चुनने के लिए उपयोगकर्ता को देता है
9	SubmitButton फॉर्म सबमिट करने के लिए बटन
10	ImageButton शीर्ष पर एक छवि के साथ क्लिक करने योग्य बटन
1 1	SingleSelectField किसी सूची से एकल आइटम का चयन करने में सक्षम बनाता है
12	MultipleSelectField सूची से कई मदों का चयन करने में सक्षम बनाता है
13	FileField फ़ाइल अपलोड करने के लिए फ़ील्ड
14	EmailField एक ईमेल इनपुट फ़ील्ड
15	URLField URL दर्ज करने के लिए एक इनपुट फ़ील्ड
16	NumberField एक नंबर स्पिनबॉक्स
17	RangeField एक नंबर का स्लाइडर

निम्नलिखित उदाहरण में, इनमें से कुछ विजेट का उपयोग करके एक फॉर्म का निर्माण किया गया है। जबकि इनमें से अधिकांश विजेट्स tw2.forms में परिभाषित हैं, CalendarDateField tw2.Dynforms मॉड्यूल में परिभाषित किया गया है। इसलिए ये दोनों मॉड्यूल tw2.core के साथ शुरुआत में आयात किए गए हैं -

import tw2.core as twc
import tw2.forms as twf
import tw2.dynforms as twd

एक ToscaWidgets फॉर्म एक वर्ग है जो इससे प्राप्त होता है tw2.forms.formआधार वर्ग। आवश्यक विजेट्स को एक लेआउट ऑब्जेक्ट के अंदर रखा जाता है। इस उदाहरण में,TableLayoutप्रयोग किया जाता है। विजेट दो स्तंभ तालिका में दिए गए हैं। पहला कॉलम कैप्शन दिखाता है और दूसरा कॉलम इनपुट या चयन क्षेत्र दिखाता है।

निम्नलिखित कंस्ट्रक्टर का उपयोग करके एक TextField ऑब्जेक्ट बनाया जाता है -

twf.TextField(size, value = None)

यदि उल्लेख नहीं किया गया है तो TextField ऑब्जेक्ट डिफ़ॉल्ट आकार लेता है और शुरू में रिक्त होता है। TextArea ऑब्जेक्ट की घोषणा करते समय, पंक्तियों और स्तंभों की संख्या का उल्लेख किया जा सकता है।

twf.TextArea("",rows = 5, cols = 30)

NumberField ऑब्जेक्ट एक TextField है जो केवल अंकों को स्वीकार कर सकता है। इसके अंदर की संख्या को बढ़ाने या घटाने के लिए दाहिनी सीमा पर ऊपर और नीचे तीर उत्पन्न होते हैं। प्रारंभिक मूल्य को कंस्ट्रक्टर में एक तर्क के रूप में भी निर्दिष्ट किया जा सकता है।

twf.NumberField(value)

कैलेंडर कैलेंडर के दाईं ओर एक कैलेंडर बटन प्रदर्शित होता है। जब एक दिनांक चयनकर्ता दबाया जाता है। उपयोगकर्ता बॉक्स में मैन्युअल रूप से एक तारीख टाइप कर सकता है या तिथि चयनकर्ता से चयन कर सकता है।

twd.CalendarDatePicker()

EmailField ऑब्जेक्ट एक TextField प्रस्तुत करता है, लेकिन इसमें पाठ ईमेल प्रारूप में होना चाहिए।

EmailID = twf.EmailField()

निम्न रूप में एक RadioButtonList भी है। इस वर्ग के निर्माता में विकल्प पैरामीटर के मान के रूप में एक सूची ऑब्जेक्ट शामिल है। प्रत्येक विकल्प के लिए एक रेडियो बटन प्रदान किया जाएगा। डिफ़ॉल्ट चयन मूल्य पैरामीटर के साथ निर्दिष्ट किया जाता है।

twf.RadioButtonList(options = ["option1","option2"],value = option1)

चेकबॉक्स सूची में प्रत्येक विकल्प के लिए चेक बॉक्स को प्रस्तुत करता है।

twf.CheckBoxList(options = [option1, option2, option3])

इस ToscaWidgets लाइब्रेरी में ड्रॉपडाउन सूची को सिंगलसेलेफील्ड कहा जाता है। विकल्प पैरामीटर के अनुरूप सूची ऑब्जेक्ट में आइटम ड्रॉप डाउन सूची बनाते हैं। दर्शनीय कैप्शन को शीघ्र_ पैरामीटर के मान के रूप में सेट किया जाता है।

twf.SingleSelectField(prompt_text = 'text', options=['item1', 'item2', 'item3'])

डिफ़ॉल्ट रूप से, फ़ॉर्म 'कैप्शन' के रूप में अपने कैप्शन के साथ सबमिट बटन प्रदर्शित करता है। एक और कैप्शन प्रदर्शित करने के लिए, एक SubmitButton ऑब्जेक्ट बनाएं और इसे वैल्यू पैरामीटर के रूप में निर्दिष्ट करें।

twf.SubmitButton(value = 'Submit')

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

action = 'URL'

निम्नलिखित कोड में, एडमिशनफ़ॉर्म नामक एक फॉर्म को ऊपर वर्णित विगेट्स का उपयोग करके बनाया गया है। RootController क्लास से पहले इस कोड को root.py में जोड़ें।

class AdmissionForm(twf.Form):
   class child(twf.TableLayout):
      NameOfStudent = twf.TextField(size = 20)
      AddressForCorrespondance = twf.TextArea("", rows = 5, cols = 30)
      PINCODE = twf.NumberField(value = 431602)
      DateOfBirth = twd.CalendarDatePicker()
      EmailID = twf.EmailField()
      Gender = twf.RadioButtonList(options = ["Male","Female"],value = 'Male')
      Subjects = twf.CheckBoxList(options = ['TurboGears', 'Flask', 'Django', 'Pyramid'])

      MediumOfInstruction = twf.SingleSelectField(prompt_text = 'choose',
         options = ['English', 'Hindi', 'Marathi', 'Telugu'])
			
      action = '/save_form'
      submit = twf.SubmitButton(value ='Submit')

अब इस कोड को नीचे की तरह सेव करें twform.html टेम्प्लेट निर्देशिका में -

<!DOCTYPE html>
<html xmlns = "http://www.w3.org/1999/xhtml"
   xmlns:py = "http://genshi.edgewall.org/"
   lang = "en">
   
   <head>
      <title>TurboGears Form Example</title>
   </head>
   
   <body>
      <div id = "tw form">
         ${form.display(value = dict(title = 'default title'))}
      </div>
   </body>
   
</html>

RootController क्लास (root.py) में, निम्नलिखित कंट्रोलर फंक्शन जोड़ें -

@expose('hello.templates.twform')
def twform(self, *args, **kw):
   return dict(page = 'twform', form = MovieForm)

एडमिशनफ़ॉर्म क्लास में, हमारे पास है stipulated/save_formएक्शन URL के रूप में। इसलिए जोड़ेंsave_form() रूटकंट्रोलर में कार्य करता है।

@expose()
def save_movie(self, **kw):
   return str(kw)

सुनिश्चित करें कि सर्वर चल रहा है (गियरबॉक्स सेवा का उपयोग करके)। दर्जhttp://localhost:8080/twform ब्राउज़र में।

सबमिट बटन दबाने पर यह डेटा पोस्ट हो जाएगा save_form() URL, जो डिक्शनरी डेटा को डिक्शनरी ऑब्जेक्ट के रूप में प्रदर्शित करेगा।

{
   'EmailID': u'[email protected]', 
   'NameOfStudent': u'Malhar Lathkar', 
   'Gender': u'Male', 
   'PINCODE': u'431602', 
   'DateOfBirth': u'2015-12-29', 
   'Subjects': [u'TurboGears', u'Flask', u'Django'], 
   'MediumOfInstruction': u'', 
   'AddressForCorrespondance': u'Shivaji Nagar\r\nNanded\r\nMaharashtra'
}

एक अच्छा फॉर्मेट विजेट लाइब्रेरी में इनपुट वेलिडेशन फीचर होना चाहिए। उदाहरण के लिए, उपयोगकर्ता को एक अनिवार्य क्षेत्र में डेटा दर्ज करने के लिए मजबूर किया जाना चाहिए, या सत्यापन के लिए किसी अन्य प्रोग्रामेटिक साधनों (जैसे जावास्क्रिप्ट फ़ंक्शन) का सहारा लिए बिना एक ईमेल क्षेत्र में एक वैध ईमेल है, तो सत्यापित करें।

ToscaWidgets Forms लाइब्रेरी के शुरुआती संस्करणों का उपयोग सत्यापन समर्थन के लिए FormEncode मॉड्यूल पर भरोसा करने के लिए किया जाता है। ToscaWidgets2 में अब tw2.core मॉड्यूल में उपलब्ध सत्यापन समर्थन उपलब्ध है। हालाँकि, अभी भी FormEncode सत्यापन तकनीकों का उपयोग करना संभव है।

ToscaWidgets फॉर्म को सत्यापन के अधीन करने के लिए, @validate डेकोरेटर का उपयोग किया जाता है।

@validate(form, error_handler, validators)

’form’ ToscaWidgets फॉर्म ऑब्जेक्ट को मान्य किया जाता है।
‘error-handler’ प्रपत्र त्रुटियों को संभालने के लिए उपयोग की जाने वाली नियंत्रक विधि है।
‘validators’ एक डिक्शनरी ऑब्जेक्ट हैं जिसमें फॉर्मनकोड सत्यापनकर्ता हैं।

Validators के प्रकार

Tw2.core मॉड्यूल में एक सत्यापनकर्ता वर्ग होता है जिसमें से अन्य सत्यापनकर्ता विरासत में मिलते हैं। इसके आधार पर एक कस्टम सत्यापनकर्ता डिजाइन करना भी संभव है। कुछ महत्वपूर्ण मान्यताओं का वर्णन नीचे दिया गया है -

LengthValidator- जांचें कि क्या एक मान निर्धारित लंबाई है। न्यूनतम और अधिकतम सीमाएं न्यूनतम और अधिकतम मापदंडों के साथ परिभाषित की जाती हैं। न्यूनतम से नीचे और ऊपर की लंबाई के लिए कस्टम संदेश अधिकतम और टोशॉर्ट और टूलॉन्ग पैरामीटर के रूप में निर्दिष्ट किए जा सकते हैं।

tw2.core.LengthValidator(min = minval, max = maxval, 
   msgs = { 'tooshort': (‘message for short length’), 
   'toolong': (‘message for long length)})

RangeValidator- आमतौर पर रेंजफिल्ड के साथ उपयोग किया जाता है। यह न्यूनतम और अधिकतम सीमाओं के भीतर एक संख्यात्मक क्षेत्र के मूल्य को मान्य करने के लिए उपयोगी है। तोशॉर्ट और टूलॉन्ग मापदंडों के लिए संदेशों को अनुकूलित किया जा सकता है।

tw2.core.RangeValidator(min = minval, max = maxval, 
   msgs = { 'tooshort': (‘message for short length’), 
   'toolong': (‘message for long length)})

IntValidator- यह वर्ग RangeValidator से लिया गया है। यह सामान्य रूप से मान्य करने के लिए उपयोग किया जाता है यदि एक सामान्य पाठ फ़ील्ड में इनपुट पूर्णांक डेटा युक्त है। न्यूनतम और अधिकतम सीमा और साथ ही त्रुटि संदेश भी सेट किए जा सकते हैं। इसके अतिरिक्त, गैर-पूर्णांक इनपुट के लिए त्रुटि संदेश को 'notint' पैरामीटर के रूप में निर्दिष्ट किया जा सकता है।

tw2.core.IntValidator(msgs = {‘notint’:’Must be Integer’})

OneOfValidator - यह सत्यापनकर्ता उपयोगकर्ता को केवल सूची में उपलब्ध विकल्पों में से एक मूल्य का चयन करने के लिए मजबूर करता है।

tw2.core.OneOfValidator(values = [option1, option2,..], 
   msgs = {‘notinlist’:’Not in List’}}

DateValidator- यह सुनिश्चित करने के लिए बहुत उपयोगी है कि उपयोगकर्ता इनपुट एक वैध तिथि है। दिनांक प्रारूप (डिफ़ॉल्ट YMD है) और त्रुटि संदेश अनुकूलन योग्य हैं। न्यूनतम और अधिकतम तिथि सीमा भी निर्दिष्ट की जा सकती है। DateTimeValidator, DateTime वर्ग की वस्तु को सत्यापित करने के लिए भी उपलब्ध है।

tw2.core.DateValidator(msgs = {format = ’%Y-%m-%d’, 
   'baddatetime': ('baddate', ('Must follow date format $format_str'))}

EmailValidator- मान्य ईमेल पते के खिलाफ उपयोगकर्ता इनपुट को मान्य करता है। यह वर्ग एक अधिक सामान्य RegexValidator से विरासत में मिला है।

tw2.core.EmailValidator(msgs = {'badregex': ('bademail', 
   ('Must be a valid email address')) }

UrlValidator- यह वर्ग RegexValidator से भी विरासत में मिला है। यह मान्य URL के लिए उपयोगकर्ता इनपुट को मान्य करता है।

tw2.core.UrlValidator(msgs = {'badregex': ('badurl', ('Must be a valid URL’)) }

MatchValidator- पुष्टि करता है कि एक क्षेत्र का मूल्य दूसरे के साथ मेल खाता है या नहीं। यह विशेष रूप से उपयोगी है, जहां उपयोगकर्ता को पासवर्ड फ़ील्ड चुनने और पुष्टि करने की आवश्यकता होती है। माचिसवैलिलेटर का विशिष्ट उपयोग नीचे दिखाया गया है -

import tw2.core as twc
import tw2.forms as twf
  
  class AdmissionForm(twf.Form):
      class child(twf.TableLayout):
         validator = twc.MatchValidator('pw', 'pwconfirm')
         pw = twf.PasswordField()
         pwconfirm = twf.PasswordField()

एक यौगिक सत्यापनकर्ता का निर्माण करना भी संभव है, जहां सत्यापन सफल होता है, यदि कोई भी चेक पास करता है। अन्य मामलों में, आप सत्यापन को सफल होने के लिए चाहते हो सकता है, केवल तभी जब इनपुट सभी चेक पास करता है। इसके लिए, tw2.core एनी और ऑल वेरिडेटर्स प्रदान करता है, जो कि एक्सपेंडेबल कंपाउंडवैलिडेटर के उपवर्ग हैं।

नॉन-ऑब्सट्रक्टिव तरीके से उपयोगकर्ता को सूचना देने के लिए टर्बोजियर्स एक बहुत ही सुविधाजनक मैसेजिंग सिस्टम प्रदान करता है। Tg मॉड्यूल में TGFlash वर्ग फ्लैशिंग संदेशों के लिए समर्थन प्रदान करता है जो एक सादे कुकी में संग्रहीत होते हैं। यह वर्ग सर्वर के साथ-साथ क्लाइंट पक्ष पर जावास्क्रिप्ट के माध्यम से फ्लैश संदेश लाने का समर्थन करता है।

render()TGFlash क्लास का तरीका, जब पायथन से ही इस्तेमाल किया जाता है, तो फ्लैश मैसेज रेंडर करने के लिए टेम्प्लेट से मंगवाया जा सकता है। यदि जावास्क्रिप्ट पर उपयोग किया जाता है, तो यह एक WebFlash ऑब्जेक्ट प्रदान करता है। यह उजागर करता हैpayload() तथा render() वर्तमान फ्लैश संदेश लाने और इसे जावास्क्रिप्ट से प्रस्तुत करने के तरीके।

जब TurboGears प्रोजेक्ट 'क्विकस्टार्ट' का उपयोग करके बनाया जाता है, तो इसमें Master.html टेम्प्लेट होता है। इसमें उस फ़्लैश ऑब्जेक्ट के एक वेरिएबल की परिभाषा है। नियंत्रक से प्राप्त इस फ्लैश संदेश की सामग्री इस टेम्पलेट में चिह्नित प्लेसहोल्डर को प्रतिस्थापित करती है।

<py:with vars = "flash = tg.flash_obj.render('flash', use_js = False)">
   <div py:if = "flash" py:replace = "Markup(flash)" />
</py:with>

tg.flash_obj WebFlash ऑब्जेक्ट है, जो किसी भी सम्मिलित टेम्पलेट के अंदर उपलब्ध है master.htmlटेम्पलेट। यह ऑब्जेक्ट वर्तमान फ़्लैश संदेश को पुनः प्राप्त करने और इसे प्रदर्शित करने की अनुमति देता है।

फ्लैश संदेश का उपयोग करके कुकी में संग्रहीत किया जाता है (जिसका नाम डिफ़ॉल्ट रूप से वेबफ्लैश है) tg.flash()तरीका। संदेश और स्थिति मापदंडों को तब पास किया जाता है।

tg.flash('Message', 'status')

यदि फ्लैश कहा जाने वाला तरीका रीडायरेक्ट करता है, तो रीडायरेक्ट किए गए पेज के अंदर फ्लैश दिखाई देगा। यदि विधि सीधे एक टेम्पलेट को उजागर करती है, तो फ्लैश स्वयं टेम्पलेट के अंदर दिखाई देगा।

सीएसएस स्टाइल को स्टेटस कोड में लगाकर फ्लैश मैसेज के रूप को अनुकूलित किया जा सकता है। एक 'क्विकस्टार्टेड' प्रोजेक्ट में एक स्टाइलशीट पब्लिक / css / style.css द्वारा अनुकूलित त्रुटि, चेतावनी, सूचना और ठीक स्थिति कोड शामिल हैं। शैलियों के साथ अधिक स्थिति कोड भी जोड़े जा सकते हैं।

#flash > .warning {
   color: #c09853;
   background-color: #fcf8e3;
   border-color: #fbeed5;
}

#flash > .ok {
   color: #468847;
   background-color: #dff0d8;
   border-color: #d6e9c6;
}

#flash > .error {
   color: #b94a48;
   background-color: #f2dede;
   border-color: #eed3d7;
}

#flash > .info {
   color: #3a87ad;
   background-color: #d9edf7;
   border-color: #bce8f1;
}

इस बाहरी स्टाइल शीट को टेम्प्लेट में शामिल करने की आवश्यकता है -

<link rel = "stylesheet" type = "text/css" media = "screen" 
   href = "${tg.url('/css/style.css')}" />

किसी भी फ्लैश मैसेज सपोर्ट का कॉन्फिगरेशन TGFlash ऑब्जेक्ट या app_cfg.py (कॉन्फिग फोल्डर) के कॉन्फिगरेशन के लिए पैरामीटर सेट करके प्राप्त किया जा सकता है। विन्यास योग्य पैरामीटर हैं -

अनु क्रमांक।	पैरामीटर और विवरण
1	flash.cookie_name कुकी का नाम फ्लैश संदेशों को संग्रहीत करने के लिए उपयोग किया जाता है। डिफ़ॉल्ट हैwebflash।
2	flash.default_status डिफ़ॉल्ट संदेश स्थिति यदि निर्दिष्ट नहीं है (डिफ़ॉल्ट रूप से ठीक है)
3	flash.template के रूप में इस्तेमाल किया flash template जब प्रदान किया गया।
4	flash.allow_html मोड़ों on/off escaping in flash messages, डिफ़ॉल्ट रूप से HTML की अनुमति नहीं है।
5	flash.js_call जावास्क्रिप्ट कोड, जो जावास्क्रिप्ट से फ्लैश प्रदर्शित करते समय चलाया जाएगा। डिफ़ॉल्ट हैwebflash.render()
6	flash.js_template string.Template उदाहरण का उपयोग फ्लैश संदेशों के लिए पूर्ण जावास्क्रिप्ट समर्थन को बदलने के लिए किया जाता है।

pop_payload() - कार्य fetches current flash message, statusऔर संबंधित जानकारी। फ्लैश मैसेज मिलने से कुकी डिलीट हो जाएगी।
render(container_id, use_js=True) - टेम्प्लेट के अंदर फ्लैश संदेश रेंडर करें या उनके लिए जावास्क्रिप्ट समर्थन प्रदान करें।
container_id DIV वह स्थान है जहां संदेश प्रदर्शित किए जाएंगे, जबकि उपयोग_js फ्लैश को HTML के रूप में या जावास्क्रिप्ट उपयोग के लिए प्रदान करने के बीच स्विच करते हैं।
status - केवल वर्तमान फ़्लैश स्थिति प्राप्त करें, फ़्लैश स्थिति प्राप्त करने से कुकी हटा दी जाएगी।
message - केवल वर्तमान फ्लैश संदेश प्राप्त करें, फ्लैश संदेश प्राप्त करने से कुकी को हटा दिया जाएगा।

कैसे करें एक साधारण फ्लैश मैसेज?

निम्नलिखित उदाहरण में, रूट कंट्रोलर क्लास में एक फ्लैश () विधि प्रदान की जाती है। यह एक फ्लैश () संदेश को कॉल करता है जिसे उजागर टेम्पलेट, फ़्लैश.html पर प्रस्तुत किया जाता है

from hello.lib.base import BaseController
from tg import expose, flash, redirect, request

class RootController(BaseController):
   @expose('hello.templates.flash')
   def flash(self, user = None):
      
      if user:
         flash(message = "Welcome "+user,status = "ok")
      else:
         flash(message = "Welcome Guest",status = "info")
      return {}

बनाने के लिए कोड flash.html टेम्प्लेट फ़ोल्डर में निम्नानुसार है

<html xmlns = "http://www.w3.org/1999/xhtml"
   xmlns:py = "http://genshi.edgewall.org/"
   xmlns:xi = "http://www.w3.org/2001/XInclude">

   <head>
      <title>TurboGears 2.3: Flash messages>/title>
      <link rel = "stylesheet" type = "text/css" media = "screen"
         href = "${tg.url('/css/style.css')}" />
			
      <py:with vars = "flash = tg.flash_obj.render('flash', use_js = False)">
         <div py:if = "flash" py:replace = "Markup(flash)" />
      </py:with>
		
   </head>

   <body>
      <h2>Hello TurboGears</h2>
   </body>
	
</html>

सर्वर शुरू करें और दर्ज करें http://localhost:8080/flash?user=MVL ब्राउज़र में

URL को इसमें बदलें http://localhost:8080/flash और शैली को अलग-अलग रूप में स्वरूपित फ़्लैश संदेश देखें

अक्सर उपयोगकर्ता के ब्राउज़र से जुड़े सरल ब्राउज़िंग डेटा को रखना आवश्यक होता है। सत्र सबसे अधिक इस्तेमाल की जाने वाली तकनीक है। सत्र डेटा का प्रतिनिधित्व करता है जिसे डिस्क फ़ाइल या डेटाबेस जैसे अधिक लगातार रूप में संग्रहीत करने की आवश्यकता नहीं होती है।

हालाँकि, TurboGears में सेशनडाटा को फाइलसिस्टम, डेटाबेस या हैश कुकी मान द्वारा समर्थित किया जा सकता है। सत्र डेटा की एक छोटी मात्रा को आमतौर पर कुकीज़ में रखा जाता है, लेकिन सत्र डेटा की बड़ी मात्रा के लिए MemCache का उपयोग किया जाता है।

MemCache एक सिस्टम-लेवल डेमॉन है। यह कैश्ड डेटा तक तेजी से पहुंच प्रदान करता है और यह अत्यंत मापनीय है। हालाँकि, यह केवल सुरक्षित सर्वर पर उपयोग करने के लिए है, और इसलिए इसे sadadmin द्वारा बनाए रखा और सुरक्षित किया जाना चाहिए।

सत्र प्रबंधन में बीकर

TurboGears सत्र प्रबंधन के लिए बीकर का उपयोग करता है। गियरबॉक्स द्वारा त्वरित रूप से शुरू किया गया एक प्रोजेक्ट सत्र डेटा को संग्रहीत करने के लिए हैशेड कुकीज़ का उपयोग करने के लिए डिफ़ॉल्ट रूप से कॉन्फ़िगर किया गया है।

जब भी कोई क्लाइंट कनेक्ट होता है, सत्र मिडलवेयर (बीकर) कुकी नाम का उपयोग करके कुकी का निरीक्षण करेगा, जिसे कॉन्फ़िगरेशन फ़ाइल में परिभाषित किया गया है। यदि कुकी नहीं मिली है, तो इसे ब्राउज़र में सेट किया जाएगा। बाद की सभी यात्राओं में, मिडलवेयर कुकी को खोजेगा और उसका उपयोग करेगा।

सत्र प्रबंधन को सक्षम करने के लिए, आयात विवरण का पालन करके सत्र वर्ग को परियोजना में शामिल किया जाना चाहिए -

from tg import session

एक सत्र चर में डेटा को बचाने के लिए -

session[‘key’] = value
session.save()

सत्र चर प्राप्त करने के लिए -

return session[‘key’]

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

delete() सत्र ऑब्जेक्ट की विधि सभी उपयोगकर्ता सत्रों को मिटा देगी -

session.delete()

भले ही यह किसी भी उत्पादन वातावरण पर सभी उपयोगकर्ता सत्रों को हटाने के लिए प्रथागत नहीं है, आप आमतौर पर प्रयोज्य या कार्यात्मक परीक्षणों के बाद सफाई के लिए करेंगे।

नीचे दिए गए सत्रों को प्रदर्शित करने के लिए एक सरल उदाहरण है। RootController वर्ग एक हैsetsession() विधि जो एक सत्र चर सेट करती है।

from hello.lib.base import BaseController
from tg import expose, session
class RootController(BaseController):
   
   @expose()
   def setsession(self):
      session['user'] = 'MVL'
      session.save()
      
      str = "<b>sessionVariable set to "+session['user'] 
      str = str+"<br><a href = '/getsession'>click here to retrieve</a></b>"
      return str
   
   @expose()
   def getsession(self):
      return "<b>value of session variable retrieved " +session['user'] +"</b>"

दर्ज http://localhost:8080/setsession

ब्राउज़र में एक लिंक की ओर जाता है http://localhost:8080/getsession जो सत्र चर को पुनः प्राप्त और प्रदर्शित करता है -

एक वेब एप्लिकेशन के प्रदर्शन को बढ़ाने के लिए, खासकर अगर यह लंबे ऑपरेशन में शामिल है, तो कैशिंग तकनीकों का उपयोग किया जाता है। TurboGears दो प्रकार की कैशिंग तकनीक प्रदान करता है -

Whole-page Caching

यह HTTP प्रोटोकॉल स्तर पर काम करता है ताकि उपयोगकर्ता के ब्राउज़र, या एक मध्यवर्ती प्रॉक्सी सर्वर (जैसे स्क्विड) के द्वारा सर्वर के संपूर्ण अनुरोधों से बचने के लिए अनुरोध को रोक सकें और फ़ाइल की कैश्ड कॉपी लौटा सकें।

Application-level Caching

यह गणना सर्वरों में संचित मूल्यों को कैश करने के लिए एप्लिकेशन सर्वर के भीतर काम करता है, अक्सर जटिल डेटाबेस प्रश्नों का परिणाम होता है, ताकि भविष्य के अनुरोध मूल्यों को फिर से गणना करने की आवश्यकता से बच सकें। वेब अनुप्रयोगों के लिए, एप्लिकेशन-स्तरीय कैशिंग जटिल प्रश्नों के परिणामों को कैश करने के लिए एक लचीला तरीका प्रदान करता है ताकि किसी दिए गए नियंत्रक विधि का कुल भार कुछ उपयोगकर्ता-विशिष्ट या केस-विशिष्ट प्रश्नों को कम किया जा सके और टेम्पलेट का ओवरहेड ओवरहेड किया जा सके ।

अनुप्रयोग-स्तरीय कैशिंग

जैसा कि पहले उल्लेख किया गया है, कैशिंग समर्थन के लिए बीकर पैकेज को सक्षम करने के लिए 'क्विकस्टार्टेड' टर्बोगियर्स परियोजना को कॉन्फ़िगर किया गया है। बीकर कैश संग्रहण के लिए उपयोग किए जाने वाले निम्नलिखित बैक-एंड का समर्थन करता है -

memory- प्रति-प्रक्रिया भंडारण के लिए उपयोग किया जाता है। यह बेहद तेज है।
filesystem - प्रति-प्रक्रिया भंडारण के साथ-साथ बहु-प्रक्रिया।
DBM database - प्रति-प्रक्रिया, बहु-प्रक्रिया, काफी तेज।
SQLAlchemy database- प्रति-डेटाबेस-सर्वर भंडारण। ऊपर दिए गए विकल्पों की तुलना में धीमी।
Memcached - मल्टी-सर्वर मेमोरी आधारित कैश।

नियंत्रक कैशिंग

त्वरित नियंत्रक कैशिंग के लिए, ए cached()डेकोरेटर उपलब्ध है। अनुरोध के विभिन्न मापदंडों के आधार पर पूरे नियंत्रक निकाय को कैश किया जाता है। की परिभाषाtg.decorators.cached() डेकोरेटर इस प्रकार है

tg.decorators.cached(key, expire, type, 
   query-args, cache_headers, invalidate_on_startup, cache_response)

मापदंडों का विवरण इस प्रकार है -

अनु क्रमांक।	पैरामीटर और विवरण
1	key कैश कुंजी उत्पन्न करने के लिए उपयोग किए जाने वाले नियंत्रक मापदंडों को निर्दिष्ट करता है।
2	expire कैश समाप्त होने से पहले सेकंड में समय, "कभी नहीं" के लिए चूक।
3	Type dbm, मेमोरी, फ़ाइल, मेम्केड, या कोई नहीं।
4	cache_headers हेडर के नामों का एक टपल प्रतिक्रिया हेडर का संकेत देता है।
5	invalidate_on_startup यदि सही है, तो हर बार एप्लिकेशन प्रारंभ होने या फिर से चालू होने पर कैश अमान्य हो जाता है।
6	cache_response प्रतिक्रिया को कैश किया जाना चाहिए या नहीं, ट्रू को चूक।

निम्नलिखित नियंत्रक कैशिंग का एक उदाहरण है -

@cached(expire = 100, type = 'memory')
@expose()
def simple(self):
   return "This is a cached controller!"

टेम्पलेट स्तर कैशिंग

जेनशी टेम्प्लेट इंजन कैश से टेम्प्लेट प्राप्त करता है यदि इसकी सामग्री नहीं बदली है। इस कैश का डिफ़ॉल्ट आकार 25 है। डिफ़ॉल्ट रूप से, टेम्प्लेट का स्वत: लोड होना सत्य है। प्रदर्शन में सुधार करने के लिए, निम्नलिखित सेटिंग्स में बनाया जा सकता हैapp_cfg.py -

[app:main]
genshi.max_cache_size = 100
auto_reload_templates = false

टेम्पलेट को कैश करने के लिए, आपको बस वापस लौटना होगा tg_cache नियंत्रक से विकल्प जो कैश्ड टेम्पलेट को प्रस्तुत करता है।

Tg_cache एक शब्दकोष है जो निम्नलिखित कुंजियों को स्वीकार करता है -

key - कैश कुंजी। Default: कोई नहीं।
expire - कैश को कितने समय तक जीवित रहना चाहिए। Default: कभी समाप्त नहीं होता हैं
type - मेमोरी, डीबीएम, मेमकेड। Default: डी बी एम।

निम्न उदाहरण टेम्पलेट कैशिंग दिखाता है -

@expose(hello.templates.user')
def user(self, username):
   return dict(user = username, tg_cache = dict(key = user, expire = 900))

हालाँकि किसी भी रिलेशनल डेटाबेस पर CRUD ऑपरेशन करने के लिए SQL में TurboGears एप्लिकेशन का उपयोग करना संभव है, लेकिन SQLAlchemy का उपयोग करना उचित है, एक पायथन टूलकिट एक शक्तिशाली ऑब्जेक्ट रिलेशन मैपर है जो एप्लिकेशन डेवलपर्स को SQL की पूर्ण शक्ति और लचीलापन देता है। SQLAlchemy के माध्यम से SQL आधारित डेटाबेस के लिए समर्थन के अलावा, TurboGears भी MongoDB डेटाबेस का समर्थन करता है, हालांकि मिंग। इस खंड में SQLAlchemy की कार्यक्षमता पर चर्चा की गई है।

ORM (ऑब्जेक्ट रिलेशनल मैपिंग) क्या है?

अधिकांश प्रोग्रामिंग लैंग्वेज प्लेटफ़ॉर्म ऑब्जेक्ट ओरिएंटेड हैं। दूसरी ओर RDBMS सर्वर में डेटा तालिकाओं के रूप में संग्रहीत किया जाता है। ऑब्जेक्ट रिलेशन मैपिंग अंतर्निहित RDBMS टेबल संरचना के लिए ऑब्जेक्ट पैरामीटर्स की मैपिंग की एक तकनीक है। एक ORM एपीआई कच्चे SQL बयान लिखने के लिए बिना CRUD संचालन करने के लिए तरीके प्रदान करता है।

जब गियरबॉक्स टूलकिट से 'क्विकस्टार्ट' कमांड का उपयोग करते हुए एक टर्बोगेयर प्रोजेक्ट बनाया जाता है, तो SQLAlchemy समर्थन डिफ़ॉल्ट कॉन्फ़िगरेशन सेटिंग्स द्वारा सक्षम होता है -

config['use_sqlalchemy'] = True
config['sqlalchemy.url'] = 'sqlite:///devdata.db'

'क्विकस्टार्टेड' परियोजना भी इसके भीतर एक मॉडल पैकेज बनाती है। उदाहरण के लिए, एक 'हैलो' प्रोजेक्ट में Hello \ hello \ मॉडल होगा। इस पैकेज में निम्नलिखित फाइलें बनाई गई हैं -

__init__.py- यह वह जगह है जहां डेटाबेस का उपयोग स्थापित किया गया है। इस मॉड्यूल में एप्लिकेशन के मॉडल ऑब्जेक्ट आयात किए जाते हैं। इसका एक DBSession - एक वैश्विक सत्र प्रबंधक भी है और एक DeclarativeBase भी है, जो सभी मॉडल वर्गों के लिए एक आधार वर्ग है।
auth.py- यह वह जगह है जहां प्रमाणीकरण स्टैक द्वारा उपयोग किए गए मॉडल परिभाषित किए गए हैं। अतिरिक्त डेटाबेस मॉडल को एक अलग मॉड्यूल के रूप में इस पैकेज में संग्रहीत किया जाता है, और __init__.py में जोड़ा जाता है।

आइए हम एक छात्र मॉडल जोड़ते हैं जो हमारे में एक छात्र तालिका स्थापित करेगा sqlite डेटाबेस।

Hello\hello\model\student.py

from sqlalchemy import *
from sqlalchemy.orm import mapper, relation, relation, backref
from sqlalchemy import Table, ForeignKey, Column
from sqlalchemy.types import Integer, Unicode, DateTime

from hello.model import DeclarativeBase, metadata, DBSession
from datetime import datetime

class student(DeclarativeBase):
   __tablename__ = 'student'

   uid = Column(Integer, primary_key = True)
   name = Column(Unicode(20), nullable = False, default = '')
   city = Column(Unicode(20), nullable = False, default = '')
   address = Column(Unicode(100), nullable = False, default = '')
   pincode = Column(Unicode(10), nullable = False, default = '')

अब इस मॉडल को इसमें जोड़ें init_model() अंदर कार्य करें __init__.py.इस फ़ंक्शन में पहले से ही एक मॉडल शामिल है। इसके नीचे हमारा छात्र मॉडल जोड़ें।

# Import your model modules here.
from hello.model.auth import User, Group, Permission
from hello.model.student import student

यदि आप चाहते हैं कि मॉडल सेट करने के समय तालिका को कुछ डेटा के साथ आरंभीकृत किया जाए, तो इसे websetup पैकेज में bootstrap.py में जोड़ें। निम्नलिखित कथनों को इसमें जोड़ेंbootstrap() समारोह।

s1 = model.student()
s1.name = 'M.V.Lathkar'
s1.city = 'Nanded'
s1.address = 'Shivaji Nagar'
s1.pincode = '431602'

model.DBSession.add(s1)
model.DBSession.flush()
transaction.commit()

मॉडल को गियरबॉक्स के सेटअप-ऐप कमांड को चलाकर आरंभ किया गया है -

gearbox setup-app

SQLAlchemy का सत्र ऑब्जेक्ट ORM ऑब्जेक्ट के सभी दृढ़ता संचालन का प्रबंधन करता है।

निम्नलिखित सत्र विधियाँ CRUD संचालन करती हैं -

DBSession.add(model object) - मैप किए गए तालिका में एक रिकॉर्ड सम्मिलित करता है।
DBSession.delete(model object) - तालिका से रिकॉर्ड हटाता है।
DBSession.query(model).all() - तालिका से सभी रिकॉर्ड को पुनः प्राप्त करता है (एक सेलेक्ट क्वेरी के अनुसार)।

आप फ़िल्टर विशेषता का उपयोग करके पुनर्प्राप्त रिकॉर्ड सेट पर फ़िल्टर लागू कर सकते हैं। उदाहरण के लिए, छात्रों की तालिका में शहर = 'हैदराबाद' के साथ रिकॉर्ड प्राप्त करने के लिए, निम्नलिखित कथन का उपयोग करें -

DBSession.query(model.student).filter_by(city = ’Hyderabad’).all()

अब हम देखेंगे कि कैसे कंट्रोलर यूआरएल के माध्यम से मॉडल के साथ बातचीत करें।

पहले हमें छात्र के डेटा को दर्ज करने के लिए एक ToscaWidgets फ़ॉर्म डिज़ाइन करें

Hello\hello\controllers.studentform.py

import tw2.core as twc
import tw2.forms as twf

class StudentForm(twf.Form):
   class child(twf.TableLayout):
      name = twf.TextField(size = 20)
      city = twf.TextField()
      address = twf.TextArea("",rows = 5, cols = 30)
      pincode = twf.NumberField()

   action = '/save_record'
   submit = twf.SubmitButton(value = 'Submit')

रूटकंट्रोलर (हेलो एप्लीकेशन का रूटहोम) में निम्नलिखित फंक्शन मैपिंग '/' जोड़कर URL जोड़ें -

from hello.controllers.studentform import StudentForm

class RootController(BaseController):
   @expose('hello.templates.studentform')
   def add(self, *args, **kw):
      return dict(page='studentform', form = StudentForm)

निम्न HTML कोड के रूप में सहेजें studentform.html टेम्प्लेट फ़ोल्डर में -

<!DOCTYPE html>
<html xmlns = "http://www.w3.org/1999/xhtml"
   xmlns:py = "http://genshi.edgewall.org/"
   lang = "en">
   
   <head>
      <title>Student Registration Form</title>
   </head>
   
   <body>
      <div id = "getting_started">
         ${form.display(value = dict(title = 'Enter data'))}
      </div>
   </body>

</html>

दर्ज http://localhost:8080/addसर्वर शुरू करने के बाद ब्राउज़र में। निम्न छात्र सूचना फ़ॉर्म ब्राउज़र में खुल जाएगा -

उपरोक्त प्रपत्र को प्रस्तुत करने के लिए डिज़ाइन किया गया है ‘/save_record’यूआरएल। इसलिए एsave_record() फ़ंक्शन को इसमें जोड़ने की आवश्यकता है root.pyइसे उजागर करने के लिए। इस फ़ंक्शन द्वारा छात्र के डेटा को इस प्रकार प्राप्त किया जाता हैdict()वस्तु। इसका उपयोग छात्र तालिका अंतर्निहित छात्र मॉडल में एक नया रिकॉर्ड जोड़ने के लिए किया जाता है।

@expose()
#@validate(form = AdmissionForm, error_handler = index1)

def save_record(self, **kw):
   newstudent = student(name = kw['name'],city = kw['city'],
      address = kw['address'], pincode = kw['pincode'])
   DBSession.add(newstudent)
   flash(message = "new entry added successfully")
   redirect("/listrec")

कृपया ध्यान दें कि सफल जोड़ के बाद, ब्राउज़र को पुनर्निर्देशित किया जाएगा ‘/listrec’ URL। यह URL एक द्वारा उजागर किया गया हैlistrec() function। यह फ़ंक्शन छात्र तालिका में सभी रिकॉर्डों का चयन करता है और उन्हें एक विधमान ऑब्जेक्ट के रूप में studentlist.html टेम्पलेट पर भेजता है। यहlistrec() फ़ंक्शन निम्नानुसार है -

@expose ("hello.templates.studentlist")
def listrec(self):
   entries = DBSession.query(student).all()
   return dict(entries = entries)

Studentlist.html टेम्प्लेट py का उपयोग करते हुए प्रविष्टियों शब्दकोश ऑब्जेक्ट के माध्यम से पुनरावृत्त करता है: निर्देश के लिए। Studentlist.html टेम्पलेट इस प्रकार है -

<html xmlns = "http://www.w3.org/1999/xhtml"
   xmlns:py = "http://genshi.edgewall.org/">
   
   <head>
      <link rel = "stylesheet" type = "text/css" media = "screen" 
         href = "${tg.url('/css/style.css')}" />
      <title>Welcome to TurboGears</title>
   </head>
   
   <body>
      <h1>Welcome to TurboGears</h1>
      
      <py:with vars = "flash = tg.flash_obj.render('flash', use_js = False)">
         <div py:if = "flash" py:replace = "Markup(flash)" />
      </py:with>
      
      <h2>Current Entries</h2>
      
      <table border = '1'>
         <thead>
            <tr>
               <th>Name</th>
               <th>City</th>
               <th>Address</th>
               <th>Pincode</th>
            </tr>
         </thead>
         
         <tbody>
            <py:for each = "entry in entries">
               <tr>
                  <td>${entry.name}</td> <td>${entry.city}</td>
                  <td>${entry.address}</td> <td>${entry.pincode}</td>
               </tr>
            </py:for>
         </tbody>
         
      </table>
   
   </body>
</html>

अब फिर से देखें http://localhost:8080/addऔर फ़ॉर्म में डेटा दर्ज करें। सबमिट बटन पर क्लिक करके, यह ब्राउज़र को studentlist.html पर ले जाएगा। यह एक 'नया रिकॉर्ड सफलतापूर्वक जोड़ा गया' संदेश भी फ्लैश करेगा।

ToscaWidgets में डेटाग्रिड नियंत्रण होता है जो डेटा को सारणीबद्ध रूप में प्रस्तुत करने का एक त्वरित तरीका प्रदान करता है। DataGrid ऑब्जेक्ट निम्नानुसार घोषित किया गया है -

from tw2.forms import DataGrid
student_grid = DataGrid(fields = [('Name', 'name'),('City', 'city'),
   ('Address','address'), ('PINCODE', 'pincode')])

अब, showgrid () फ़ंक्शन छात्र तालिका में सभी रिकॉर्ड्स को पुनः प्राप्त करता है और डेटा को ग्रिड.html टेम्पलेट में उजागर करता है। पहले शोएरगिड () फ़ंक्शन के लिए कोड और फिर ग्रिड। कोड नीचे दिया गया है -

ग्रिड दिखाएं()

@expose('hello.templates.grid')
def showgrid(self):
   data = DBSession.query(student).all()
   return dict(page = 'grid', grid = student_grid, data = data)

grid.html

<!DOCTYPE html>
<html xmlns = "http://www.w3.org/1999/xhtml"
   xmlns:py = "http://genshi.edgewall.org/"
   lang = "en">
   
   <head>
      <title>Student Registration Form</title>
   </head>
   
   <body>
      <div id = "getting_started">
         <div>${grid.display(value = data)}</div>
      </div>
   </body>

</html>

निम्नलिखित सारणीबद्ध डेटा कब प्रदर्शित किया जाएगा http://localhost:8080/showlist URL ब्राउज़र में दर्ज किया गया है -

टर्बोजियर्स पेजों में आउटपुट को विभाजित करने के लिए पेजिनेट () नामक एक सुविधाजनक डेकोरेटर प्रदान करता है। यह डेकोरेटर एक्सपोज़ () डेकोरेटर के साथ संयुक्त है। @Paginate () डेकोरेटर क्वेरी परिणाम के शब्दकोश ऑब्जेक्ट को तर्क के रूप में लेता है। इसके अलावा, प्रति पृष्ठ रिकॉर्ड की संख्या items_per_page विशेषता के मूल्य द्वारा तय की जाती है। सुनिश्चित करें कि आप अपने कोड में tg.decorators से पेजेंट फ़ंक्शन आयात करते हैं।

रूटराइट में रिवाइराइट लिस्ट्रेक () फ़ंक्शन निम्नानुसार है -

from tg.decorators import paginate
class RootController(BaseController):
   @expose ("hello.templates.studentlist")
   @paginate("entries", items_per_page = 3)
	
   def listrec(self):
      entries = DBSession.query(student).all()
      return dict(entries = entries)

प्रति पृष्ठ आइटम तीन होने तय हैं।

Studentlist.html टेम्पलेट में, पृष्ठ नेविगेशन को tmpl_context.paginators.entries.pager () py के नीचे: निर्देशन के लिए जोड़कर सक्षम किया गया है। इस टेम्प्लेट का कोड निम्नानुसार होना चाहिए -

<html xmlns = "http://www.w3.org/1999/xhtml"
   xmlns:py = "http://genshi.edgewall.org/">
   
   <head>
      <link rel = "stylesheet" type = "text/css" media = "screen" 
         href = "${tg.url('/css/style.css')}" />
      <title>Welcome to TurboGears</title>
   </head>
   
   <body>
      
      <h1>Welcome to TurboGears</h1>
		
      <py:with vars = "flash = tg.flash_obj.render('flash', use_js = False)">
         <div py:if = "flash" py:replace = "Markup(flash)" />
      </py:with>
      
      <h2>Current Entries</h2>
		
      <table border = '1'>
         <thead>
            <tr>
               <th>Name</th>
               <th>City</th>
               <th>Address</th>
               <th>Pincode</th>
            </tr>
         </thead>
         
         <tbody>
            <py:for each = "entry in entries">
               <tr>
                  <td>${entry.name}</td> <td>${entry.city}</td>
                  <td>${entry.address}</td> <td>${entry.pincode}</td>
               </tr>
            </py:for>
				
            <div>${tmpl_context.paginators.entries.pager()}</div>
         </tbody>
         
      </table>
   
   </body>

</html>

दर्ज http://localhost:8080/listrecब्राउज़र में। तालिका में रिकॉर्ड का पहला पृष्ठ प्रदर्शित किया जाता है। इस तालिका के शीर्ष पर, पृष्ठ संख्याओं के लिंक भी देखे जाते हैं।

डाटाग्रिड में पेजेशन सपोर्ट कैसे जोड़ें

डेटाग्रिड में पेजेशन सपोर्ट जोड़ना भी संभव है। निम्नलिखित उदाहरण में, पृष्ठांकित डेटाग्रिड को एक्शन बटन प्रदर्शित करने के लिए डिज़ाइन किया गया है। कार्रवाई बटन को सक्रिय करने के लिए डेटाग्रेड ऑब्जेक्ट का निर्माण निम्नलिखित कोड के साथ किया जाता है -

student_grid = DataGrid(fields = [('Name', 'name'),('City', 'city'),
   ('Address','address'), ('PINCODE', 'pincode'),
   ('Action', lambda obj:genshi.Markup('<a
      href = "%s">Edit</a>' % url('/edit',
      params = dict(name = obj.name)))) ])

यहां एक्शन बटन डेटा ग्रिड में प्रत्येक पंक्ति के नाम पैरामीटर से जुड़ा हुआ है।

फिर से लिखें showgrid() कार्य निम्नानुसार है -

@expose('hello.templates.grid')
@paginate("data", items_per_page = 3)

def showgrid(self):
   data = DBSession.query(student).all()
   return dict(page = 'grid', grid = student_grid, data = data)

ब्राउज़र निम्न के अनुसार पृष्ठांकित डेटा दिखाता है -

तीसरी पंक्ति में संपादन बटन पर क्लिक करके, यह निम्नलिखित URL पर पुनर्निर्देशित करेगा http://localhost:8080/edit?name=Rajesh+Patil

TurboGears tgext.admin एक्सटेंशन प्रदान करता है, जो tgext.crud और sprox द्वारा संचालित है। यह स्प्रोक्स डेटाबेस स्कीमा से सीधे वेब विजेट के निर्माण के लिए उपयोग किया जाने वाला पैकेज है। इसका उपयोग स्वचालित रूप से सरल प्रशासन पेज बनाने के लिए किया जा सकता है और नए क्विकस्टार्ट किए गए एप्लिकेशन में टूलकिट / एडमिन पेज को पॉवरिंग कर रहा है।

डिफ़ॉल्ट रूप से, व्यवस्थापक आपके प्रोजेक्ट मॉडल / __ init__.py में आयात किए गए सभी मॉडलों के लिए एक ऑटोजेनरेटेड एक्सेस प्रदान करेगा।

TurboGears एडमिन कैसे बनाएं

डिफ़ॉल्ट TurboGears व्यवस्थापक को AdminController वर्ग के ऑब्जेक्ट के रूप में बनाया गया है -

from tgext.admin.controller import AdminController

class RootController(BaseController):
   admin = AdminController(model, DBSession, config_type = TGAdminConfig)

यह डिफ़ॉल्ट TurboGears व्यवस्थापक कॉन्फ़िगरेशन के साथ सभी मॉडलों के लिए एक व्यवस्थापक बनाता है।

प्रबंधक के माध्यम से, सेटअप चरण के दौरान एक उपयोगकर्ता बनाया गया है। अब, TurboGears व्यवस्थापक पर पहुँच प्राप्त करना संभव हैhttp://localhost:8080/adminपहली बार जब यह पृष्ठ एक्सेस किया जाता है, तो यह प्रमाणीकरण के लिए पूछेगा। आप बस उपयोगकर्ता का उपयोगकर्ता नाम और पासवर्ड प्रदान कर सकते हैं जो हमारे लिए सेटअप-कमांड कमांड बनाया गया है -

Username: manager
Password: managepass

त्वरित परियोजना में प्रवेश करने के लिए, रूटरकंट्रोलर वर्ग (नियंत्रकों / root.py) के लिए निम्न कार्य जोड़ें।

from hello.lib.base import BaseController
from tg import expose, flash, redirect, request,url, lurl
from tg import redirect, validate
from hello import model
from hello.model import DBSession
from tgext.admin.tgadminconfig import BootstrapTGAdminConfig as TGAdminConfig
from tgext.admin.controller import AdminController
from tg.exceptions import HTTPFound

class RootController(BaseController):
   admin = AdminController(model, DBSession, config_type =  TGAdminConfig)
   
   @expose('hello.templates.index')
   def index(self):
      return dict(page = 'index')
   
   @expose('hello.templates.login')
   def login(self, came_from = lurl('/'), failure = None,    login = ''):
	
      if failure is not None:
         if failure == 'user-not-found':
            flash(_('User not found'), 'error')
         elif failure == 'invalid-password':
            flash(_('Invalid Password'), 'error')
			
      login_counter = request.environ.get('repoze.who.logins', 0)
		
      if failure is None and login_counter > 0:
         flash(_('Wrong credentials'), 'warning')
		 
      return dict(page = 'login', login_counter = str(login_counter), 
         came_from = came_from, login = login)
   @expose()
	
   def post_login(self, came_from = lurl('/')):
      if not request.identity:
         
         login_counter = request.environ.get('repoze.who.logins', 0) + 1
            redirect('/login', params = dict(came_from = came_from,
            __logins = login_counter))
		
         userid = request.identity['repoze.who.userid']
         flash(('Welcome back, %s!') % userid)
			
         return HTTPFound(location = came_from)

सर्वर शुरू करने और विजिट करने के बाद server क्विकस्टार्ट ’एप्लिकेशन में लॉगिन करें http://localhost:8080/loginऔर फिर ऊपर दिखाए गए अनुसार प्रबंधक क्रेडेंशियल्स दर्ज करें। ब्राउज़र नीचे दिखाए गए जैसे एक व्यवस्थापक पृष्ठ प्रदर्शित करेगा -

पृष्ठ इस एप्लिकेशन में बनाए गए सभी मॉडल दिखाता है। इसमें प्रविष्टियों की सूची देखने के लिए आप किसी भी मॉडल पर क्लिक कर सकते हैं -

इस डेटाग्रिड के शीर्ष पर 'नया' बटन रिकॉर्ड को जोड़ने की अनुमति देता है। इसी प्रकार, इस डेटाग्रिड के एक्शन कॉलम में एक रिकॉर्ड को संपादित करने और हटाने के लिए एक्शन बटन भी दिए गए हैं। सशर्त रूप से रिकॉर्ड का चयन करने के लिए एक खोज बॉक्स भी प्रदर्शित किया जाता है।

TurboGears एप्लिकेशन गियरबॉक्स टूलकिट के क्विकस्टार्ट और सेटअप-ऐप विकल्पों द्वारा बनाई गई है, जिसमें डिफ़ॉल्ट रूप से प्राधिकरण और प्रमाणीकरण समर्थन सक्षम है। ऑरेकलडैम में घोषित मॉडल को बूटस्ट्रैप थ्रीडी में दिए गए मानों के अनुसार सेट और इनिशियलाइज़ किया जाता है।

निम्नलिखित मॉडल ओरेकल में घोषित किए गए हैं -

उपयोगकर्ता मॉडल

उपयोगकर्ता मॉडल में tg_user तालिका का डिज़ाइन है। इस तालिका का उपयोग रिपॉज.हो पैकेज द्वारा किया जाता है। यह repose.who पैकेज एक शक्तिशाली और साथ ही WSGI अनुप्रयोगों के लिए एक एक्स्टेंसिबल प्रमाणीकरण पुस्तकालय है। उपयोगकर्ता मॉडल की संरचना इस प्रकार है -

class User(DeclarativeBase):

"""
   __tablename__ = 'tg_user'
   
   user_id = Column(Integer, autoincrement = True, primary_key=True)
   user_name = Column(Unicode(16), unique = True, nullable = False)
   email_address = Column(Unicode(255), unique = True,nullable=False)
                                             
   display_name = Column(Unicode(255))
   _password = Column('password', Unicode(128))
   created = Column(DateTime, default = datetime.now)

इस समूह के मॉडल में परिभाषा tg_group तालिका है। इसकी परिभाषा ओडिशा के रूप में दी गई है -

class Group(DeclarativeBase):
   __tablename__ = 'tg_group'
   
   group_id = Column(Integer, autoincrement = True,primary_key = True)
   group_name = Column(Unicode(16),unique = True,nullable = False)
   display_name = Column(Unicode(255))
   created = Column(DateTime, default = datetime.now)

एक अन्य मॉडल अनुमति भी स्थापित की गई है, जिसमें अनुमति परिभाषा शामिल है।

class Permission(DeclarativeBase):
   __tablename__ = 'tg_permission'
   
   permission_id = Column(Integer,autoincrement = True,primary_key = True)
   permission_name = Column(Unicode(63), unique = True, nullable = False)
   description = Column(Unicode(255))

मॉडल स्थापित करने के समय, निम्न डेटा इन तालिकाओं में जोड़ा जाता है -

u = model.User()
u.user_name = 'manager'
u.display_name = 'Example manager'
u.email_address = '[email protected]'
u.password = 'managepass'

model.DBSession.add(u)
g = model.Group()
g.group_name = 'managers'
g.display_name = 'Managers Group'
g.users.append(u)

model.DBSession.add(g)
p = model.Permission()
p.permission_name = 'manage'
p.description = 'This permission gives an administrative right'
p.groups.append(g)

model.DBSession.add(p)
u1 = model.User()
u1.user_name = 'editor'
u1.display_name = 'Example editor'
u1.email_address = '[email protected]'
u1.password = 'editpass'

model.DBSession.add(u1)

मॉडल को समर्पित करें

टीजी पैकेज में विधेय मॉड्यूल में विधेय चेकर्स के लिए परिभाषाएं होती हैं। एक विधेय एक शर्त है जिसे उपयोगकर्ता को अनुरोधित स्रोत तक पहुंचने में सक्षम होने के लिए मिलना चाहिए। ऐसी विधेय, या स्थिति, अधिक विधेय से बनी हो सकती है - जिन्हें यौगिक विधेय कहा जाता है। क्रिया नियंत्रक, या नियंत्रक, केवल एक ही विधेय हो सकता है, यह एकल या यौगिक हो।

यदि कोई उपयोगकर्ता लॉग इन नहीं है, या उसके पास उचित अनुमतियां नहीं हैं, तो यह प्रेडेटेट चेकर एक 401 (HTTP अनधिकृत) फेंकता है, जो उपयोगकर्ता को लॉग इन करने की अनुमति देते हुए लॉगिन पेज प्रदर्शित करने के लिए repoze.who मिडलवेयर द्वारा पकड़ा जाता है और रीडायरेक्ट करता है। जब वे किए जाते हैं तो उपयोगकर्ता उचित पृष्ठ पर वापस आ जाता है।

Tg.predicates मॉड्यूल में परिभाषित विभिन्न स्थितियाँ या विधेय हैं -

अनु क्रमांक।	tg.predicates मॉड्यूल और विवरण
1	All जांचें कि क्या निर्दिष्ट सभी विधेय पूर्ण हुए हैं
2	Any जाँच करें कि क्या कम से कम एक निर्दिष्ट विधेय मिलते हैं
3	is_user जांचें कि प्रमाणित उपयोगकर्ता का उपयोगकर्ता नाम निर्दिष्ट है
4	in_group जांचें कि उपयोगकर्ता विशिष्ट समूह से संबंधित है।
5	in_all_groups जांचें कि उपयोगकर्ता सभी निर्दिष्ट समूहों से संबंधित है।
6	in_any_group जांचें कि उपयोगकर्ता निर्दिष्ट समूहों में से कम से कम एक का है।
7	is_anonymous जांचें कि वर्तमान उपयोगकर्ता अनाम है।
8	has_permission जांचें कि वर्तमान उपयोगकर्ता के पास निर्दिष्ट अनुमति है।
9	has_all_permissions जांचें कि वर्तमान उपयोगकर्ता को सभी निर्दिष्ट अनुमतियाँ दी गई हैं।
10	has_any_permission जाँच लें कि उपयोगकर्ता के पास कम से कम एक निर्दिष्ट अनुमतियाँ हैं।

उदाहरण के लिए, यदि आपके पास एक विधेय है, जो है grant access user belonging to customers group, तो आप निम्नलिखित अंतर्निहित जांचकर्ता का उपयोग कर सकते हैं -

from tg.predicates import in_group
p in_group(‘customers’)

निम्नलिखित विधेय परीक्षक 'रूट' उपयोगकर्ता या 'प्रबंधन' की अनुमति के साथ किसी को भी पहुंच प्रदान करेगा -

from tg.predicates import Any, is_user, has_permission
p = Any(is_user('root'), has_permission('manage'), 
   sg = 'Only administrators can remove blog posts')

TurboGears भी MongoDB दस्तावेज़ डेटाबेस का समर्थन करता है। यह मिंग, एक ऑब्जेक्ट दस्तावेज़ मैपर एपीआई का उपयोग करता है। मिंग का उपयोग SQLAlchemy के समान है। मिंग क्वेरी भाषा ने SQLAlchemy आधारित TurboGears प्रोजेक्ट को मिंग में पोर्ट करना संभव बनाता है।

PyMongo क्या है

PyMongo एक पायथन वितरण है जिसमें MongoDB के साथ काम करने के लिए उपकरण हैं। मिंग प्रदान करता है PyMongo प्रदान करता है -

घोषणात्मक मॉडल
स्कीम मान्यता और रूपांतरण
स्कीमा विकास
शुद्ध इनमोरी मोंगियोबडी कार्यान्वयन
कार्य की इकाई
पहचान मानचित्र
एक-से-कई, कई-से-एक और कई-कई रिश्ते

सबसे पहले, आपको MongoDB डाउनलोड और इंस्टॉल करना होगा। MongoDB के नवीनतम वितरण से डाउनलोड किया जा सकता हैhttps://www.mongodb.org/downloads

Windows पर, -bbath विकल्प प्रदान करके MongoDB सर्वर शुरू करें -

C:\mongodb\bin>Mongod --dbpath d:\mongo

D:\mongo folderMongoDB डेटाबेस को संग्रहीत करने के लिए निर्दिष्ट है। सर्वर पर सुनना शुरू कर देता हैhttp://localhost:27017. अब MongoDB शेल शुरू करने के लिए निम्नलिखित कमांड का उपयोग करें -

C:\mongodb\bin>Mongo

हमारा MongoDB वातावरण अब तैयार है।

अब एक TurboGears परियोजना के साथ-विकल्प बनाएँ -

gearbox quickstart --ming Hello

यह त्वरित परियोजना SQLAlchemy संस्करण के लिए प्रदान की गई की तरह एक प्रमाणीकरण और प्राधिकरण परत प्रदान करेगी। यह एप्लिकेशन अब स्थानीय मशीन पर पोर्ट 27017 पर एक सर्वर से कनेक्ट करने का प्रयास करेगा। प्रोजेक्ट फ़ोल्डर में development.ini फ़ाइल में निम्न सेटिंग्स हैं -

ming.url = mongodb://localhost:27017/
ming.db = hello

निम्नलिखित कमांड का उपयोग करके परियोजना को सेट करें -

Python setup.py develop

प्रोजेक्ट फ़ोल्डर में मॉडल सबफ़ोल्डर होते हैं जिनमें निम्नलिखित फाइलें होती हैं -

__init__.py - यह वह जगह है जहाँ databaseपहुंच स्थापित की गई है। आपका संग्रह होना चाहिएimported into this module। उदाहरण के लिए, हम इस पैकेज में छात्र संग्रह जोड़ेंगे।
session.py - यह फ़ाइल को परिभाषित करता है session of your database connection। जब भी आपको कोई घोषणा करनी हो, तो आपको हर बार यह आयात करना होगाMappedClass सत्र निर्दिष्ट करने के लिए perform queries।
auth.py - यह फाइल बन जाएगी, अगर आपके पास है enabled authentication and authorizationजल्दी में। यह तीन संग्रहों को परिभाषित करता हैrepoze.who, जो आगे निर्भर करता है: उपयोगकर्ता, समूह और अनुमति।

अपने संग्रह को परिभाषित करना

डिफ़ॉल्ट रूप से, TurboGears मिंग को एक घोषणात्मक मोड में कॉन्फ़िगर करता है। यह SQLAlchemy घोषणात्मक समर्थन के समान है और MappedClass वर्ग से इनहेरिट करने के लिए प्रत्येक मॉडल की आवश्यकता है।

मैप्डक्लास को आवश्यकता है कि एक __mongometa__ उपवर्ग अंदर उपलब्ध हो, जो आगे दस्तावेजों को संग्रहीत करने वाले संग्रह के नाम और दस्तावेजों को संग्रहीत करने के लिए उपयोग किए जाने वाले सत्र के बारे में विवरण प्रदान करता है।

मैप्डक्लास में दस्तावेज़ में फ़ील्ड की परिभाषा भी शामिल है। मिंग के ओड्म मॉड्यूल में विभिन्न प्रकार के क्षेत्र गुण हैं -

FieldProperty
ForeignIdProperty
RelationProperty

ming.schema module निम्न डेटा प्रकारों को परिभाषित करता है -

ming.schema.Anything
ming.schema.Array
ming.schema.Binary
ming.schema.Bool
ming.schema.Float
ming.schema.Int
ming.schema.ObjectId
ming.schema.Scalar
ming.schema.String

इस मॉडल में छात्र संग्रह को जोड़ने के लिए, निम्न कोड को छात्र / छात्रावास के हेल्लो के रूप में सहेजें।

नमस्कार \ मॉडल \ student.py

from ming import schema
from ming.odm import MappedClass
from ming.odm import FieldProperty, ForeignIdProperty
from hello.model import DBSession
   
Class student(MappedClass):
   class __mongometa__:
      session = DBSession
      name = 'student'
      
   _id = FieldProperty(schema.ObjectId)
   name = FieldProperty(schema.String(required = True))
   city = FieldProperty(schema.String(if_missing = ''))
   address = FieldProperty(schema.String(if_missing = ''))
   pincode = FieldProperty(schema.String(if_missing = ''))

अंत में, इस मॉडल को हैलो \ मॉडल \ __ init__.py में शामिल करें

# Import your model modules here.
from hello.model.auth import User, Group, Permission
from hello.model.student import student

इन मॉडलों को स्थापित करने के लिए, निम्न गियरबॉक्स कमांड चलाएं -

Gearbox setup-app

निम्नलिखित गियरबॉक्स कमांड के साथ सर्वर शुरू करें -

Gearbox serve –reload –debug

इस एप्लिकेशन का होमपेज खोलें (http://localhost:8080/)और प्रबंधक क्रेडेंशियल के साथ लॉगिन करें। इस एप्लिकेशन का व्यवस्थापक पृष्ठ सेट किए गए मॉडल की सूची दिखाएगा। (प्रबंधक, पासवर्ड प्रबंधन के रूप में लॉगिन करें)

संग्रहों के निर्माण को MongoDB वेब इंटरफ़ेस के साथ-साथ MongoDB शेल में भी सत्यापित किया जा सकता है।

ODMSession का उपयोग निम्नलिखित कार्यों का उपयोग करके कई डेटाबेस संचालन करने के लिए किया जाता है -

model.query.find()
model.query.find_and_modify()
model.remove()
model.update()
model.flush()

एक ToscoWidget फ़ॉर्म डिज़ाइन करना

अब हम छात्र डेटा दर्ज करने और छात्र मॉडल के आधार पर तालिका में जोड़ने के लिए एक ToscoWidget फ़ॉर्म डिज़ाइन करेंगे।

निम्नलिखित एक studentform.py बनाने के लिए कोड है -

नमस्कार \ नियंत्रकों \ studentform.py

import tw2.core as twc
import tw2.forms as twf
   
class StudentForm(twf.Form):

   class child(twf.TableLayout):
      name = twf.TextField(size = 20)
      city = twf.TextField()
      address = twf.TextArea("",rows = 5, cols = 30)
      pincode = twf.NumberField()
		
   action = '/save_record'
   submit = twf.SubmitButton(value = 'Submit')

एप्लिकेशन के रूटकंट्रोलर '/ ऐड' URL जो ऐड () फ़ंक्शन को कॉल करता है, जो ब्राउज़र में उपरोक्त डिज़ाइन किए गए फॉर्म को खोल देगा। इसका सबमिट बटन तब save_record () फ़ंक्शन को आमंत्रित करता है। यह प्रपत्र डेटा को पुनर्प्राप्त करता है और इसे छात्र तालिका में सहेजता है और एप्लिकेशन को '/ listrec' URL पर पुनर्निर्देशित करता है, जो छात्र सूची को उजागर करता है।

इस गतिविधि के लिए root.py इस प्रकार है -

हैलो / नियंत्रक / root.py

from hello.lib.base import BaseController
from tg import expose, flash, redirect, request,url, lurl
from tg import redirect, validate
from hello import model
from hello.model import DBSession
from hello.model.student import student
   
from hello.controllers.studentform import StudentForm
   
class RootController(BaseController):
   @expose()
   def index(self):
      return "<h1>Hello World</h1>"
         
   @expose ("hello.templates.studentlist")
   def listrec(self):
      entries = student.query.find()
      return dict(entries = entries)
               
   @expose('hello.templates.studentform')
   def add(self, *args, **kw):
      return dict(page = 'studentform', form = StudentForm)
         
   @expose()
   def save_record(self, **kw):
      newstudent = student(name = kw['name'],city = kw['city'],
         address = kw['address'], pincode = kw['pincode'])
      DBSession.flush()
      flash(message = "new entry added successfully")
      redirect("/listrec")

निम्नलिखित टेम्पलेट टेम्पलेट फ़ोल्डर में बनाए गए हैं -

नमस्कार \ टेम्पलेट्स \ studentform.html

<!DOCTYPE html>
<html xmlns = "http://www.w3.org/1999/xhtml" 
   xmlns:py = "http://genshi.edgewall.org/" lang = "en">
	
   <head>
      <title>Student Registration Form</title>
   </head>
	

   <body>
      <div id = "getting_started">
         ${form.display(value = dict(title = 'Enter data'))}
      </div>
   </body>
	
</html>

नमस्कार \ टेम्पलेट्स \ studentlist.html

<html xmlns = "http://www.w3.org/1999/xhtml" 
   xmlns:py = "http://genshi.edgewall.org/">

   <head>
      <link rel = "stylesheet" type = "text/css" media = "screen" 
         href = ${tg.url('/css/style.css')}" /> <title>Welcome to TurboGears</title> </head> <body> <h1>Welcome to TurboGears</h1> <py:with vars = "flash = tg.flash_obj.render('flash', use_js = False)"> <div py:if = "flash" py:replace = "Markup(flash)" /> </py:with> <h2>Current Entries</h2> <table border = '1'> <thead> <tr> <th>Name</th> <th>City</th> <th>Address</th> <th>Pincode</th> </tr> </thead> <tbody> <py:for each = "entry in entries"> <tr> <td>${entry.name}</td>
                  <td>${entry.city}</td> <td>${entry.address}</td>
                  <td>${entry.pincode}</td>
               </tr>
            </py:for>
         </tbody>
      </table>
		
   </body>
	
</html>

सर्वर को पुनरारंभ करें और दर्ज करें http://localhost:8080/add ब्राउज़र में -

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

गियरबॉक्स टूलकिट में मचान कमांड होता है, जो टर्बोबियर्स एप्लिकेशन के नए घटकों को जल्दी से बनाने के लिए बहुत उपयोगी है। गियरबॉक्स के क्विकस्टार्ट कमांड द्वारा उत्पन्न एप्लिकेशन में मॉडल फ़ोल्डर (मॉडल ओरिजिन.नेटमप्लेट), एक टेम्प्लेट फ़ोल्डर (टेंप्लेट html.template) और एक नियंत्रक फ़ोल्डर (कंट्रोलरहोम। टेमप्लेट) में एक कंकाल टेम्पलेट है। इन '.template' फ़ाइलों को एक अनुप्रयोग के लिए नए मचान बनाने के लिए आधार के रूप में उपयोग किया जाता है

उदाहरण के लिए, mymodel नामक एक नया मॉडल बनाने के लिए, बस निम्नलिखित कमांड चलाएँ -

gearbox scaffold model mymodel

यह कमांड मॉडल / mymodel.py को इसमें परिभाषित नए मॉडल वर्ग के साथ उत्पन्न करेगा।

# -*- coding: utf-8 -*-
"""Mymodel model module."""
from sqlalchemy import *
from sqlalchemy import Table, ForeignKey, Column
from sqlalchemy.types import Integer, Unicode, DateTime, LargeBinary
from sqlalchemy.orm import relationship, backref
from hello.model import DeclarativeBase, metadata, DBSession

class Mymodel(DeclarativeBase):
   __tablename__ = 'mymodels'
   
   uid = Column(Integer, primary_key = True)
   data = Column(Unicode(255), nullable = False)
   
   user_id = Column(Integer, ForeignKey('tg_user.user_id'), index = True)
   user = relationship('User', uselist = False,
      backref = backref('mymodels',cascade = 'all, delete-orphan'))
   __all__ = ['Mymodel']

उपयोगकर्ता अब अपनी आवश्यकता के अनुसार तालिका संरचना में संशोधन कर सकते हैं और फिर इसे अंदर आयात कर सकते हैं model/__init__.py आवेदन के अंदर मॉडल उपलब्ध कराने के लिए।

एक मॉडल बनाने के लिए, इसे नियंत्रित करने के लिए एक नियंत्रक वर्ग और एक सूचकांक पृष्ठ इन तीनों घटकों को एक साथ निम्नलिखित कमांड द्वारा बनाया जा सकता है।

gearbox scaffold model controller template mymodel

इस आदेश के परिणामस्वरूप नियंत्रकों \ mymodel.py जिसमें MymodelController वर्ग को विधिवत परिभाषित किया जाएगा।

# -*- coding: utf-8 -*-
"""Mymodel controller module"""

from tg import expose, redirect, validate, flash, url
# from tg.i18n import ugettext as _
# from tg import predicates

from hello.lib.base import BaseController
# from hello.model import DBSession

class MymodelController(BaseController):
   # Uncomment this line if your controller requires an authenticated user
   # allow_only = predicates.not_anonymous()
   
   @expose('hello.templates.mymodel')
   def index(self, **kw):
      return dict(page = 'mymodel-index')

इस नियंत्रक का उपयोग करना शुरू करने के लिए, इसे अपने एप्लिकेशन रूटकंट्रोलर के अंदर माउंट करें बस MymodelController की एक आवृत्ति को परिभाषित करें। कंट्रोलर \ root.py - में इन पंक्तियों को जोड़ें

From hello.controller.mymodel import MymodelController

class RootController(BaseController): mymodel = MymodelController()

टेम्प्लेट फ़ोल्डर में एक टेम्प्लेट मचान टेम्पलेट \ mymodel.html भी बनाया जाएगा। यह '/ mymodel' URL के लिए एक इंडेक्स पेज की तरह काम करेगा।

उत्पन्न हुआ mymodel.html file टेम्प्लेट फ़ोल्डर में निम्नानुसार होगा -

<html xmlns = "http://www.w3.org/1999/xhtml"
   xmlns:py = "http://genshi.edgewall.org/"
   xmlns:xi = "http://www.w3.org/2001/XInclude">
	
   <xi:include href = "master.html" />
	
   <head>
      <title>Mymodel</title>
   </head>
	
   <body>
      <div class = "row">
         <div class = "col-md-12">
            <h2>Mymodel</h2>
            <p>Template page for Mymodel</p>
         </div>
      </div>
   </body>
	
</html>

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

Hook - यह एक ऐसा तंत्र है जिसके द्वारा किसी घटना को परिभाषित करना संभव है, और पंजीकृत श्रोताओं को सूचित किया जाता है कि कब और कैसे घटनाओं का उत्सर्जन होता है।
Controller Wrapper- यह टर्बोबियर्स और कंट्रोलर के बीच बैठता है, ताकि डेकोरेटर की तरह कंट्रोलर का विस्तार संभव हो। इस प्रकार, इसे किसी भी तृतीय-पक्ष नियंत्रक एप्लिकेशन से जोड़ा जा सकता है।
Application Wrapper - यह किसी भी WSGI मिडलवेयर के समान है, लेकिन TurboGears के संदर्भ में ही काम करता है।

इस अध्याय में, हम चर्चा करेंगे कि मौजूदा एप्लिकेशन के अंदर हुक का उपयोग कैसे करें।

हुक्स

हुक एप्लिकेशन के कॉन्फ़िगरेशन फ़ाइल में पंजीकृत घटनाएं हैं app_cfg.py। किसी भी नियंत्रक को तब इवेंट डेकोरेटर्स द्वारा इन घटनाओं के लिए आदी किया जाता है।

निम्नलिखित हुक टर्बोग्रियर्स में परिभाषित किए गए हैं -

अनु क्रमांक।	हुक और विवरण
1	Startup() आवेदन व्यापक, केवल जब आवेदन शुरू होता है कहा जाता है।
2	shutdown() आवेदन विस्तृत होने पर ही बुलाया जाता है।
3	configure_new_app नया एप्लिकेशन एप्लिकेशन कॉन्फ़िगरेशनकर्ता द्वारा बनाया गया है।
4	before_config(app) आवेदन व्यापक, आवेदन बनाने के बाद सही कहा जाता है, लेकिन विकल्प और मिडलवेयर स्थापित करने से पहले
5	after_config(app) आवेदन व्यापक, सब कुछ स्थापित करने के बाद परिष्करण कहा जाता है।
6	before_validate सत्यापन करने से पहले फोन किया
7	before_call सत्यापन के बाद कॉल किया जाता है, वास्तविक नियंत्रक विधि को कॉल करने से पहले।
8	before_render नियंत्रक टेम्पलेट को प्रस्तुत करने से पहले कॉल किया जाता है, आउटपुट नियंत्रक रिटर्न मान है।
9	after_render कंट्रोलर टेम्प्लेट रेंडर करने के बाद कॉल किया जाता है।

एक हुक पंजीकृत करें

के लिए register a Hook, में कार्य बनाएँ app_cfg.py और फिर निम्नलिखित कोड का उपयोग करके उन्हें पंजीकृत करें -

tg.hooks.register(hookane, function, controller)

निम्नलिखित कोड में, on_startup, on_shutdown और इससे पहले_रेंडर हुक app_cfg.py में पंजीकृत हैं।

def on_startup():
   print 'hello, startup world'
   
def on_shutdown():
   print 'hello, shutdown world'
   
def before_render(remainder, params, output):
   print 'system wide before render'
   
# ... (base_config init code)
tg.hooks.register('startup', on_startup)
tg.hooks.register('shutdown', on_shutdown)
tg.hooks.register('before_render', before_render)

पहले_रेंडर हुक रूटकंट्रोलर में एक नियंत्रक फ़ंक्शन के साथ पंजीकृत है। कंट्रोलर \ root.py में निम्न कोड जोड़ें।

from tg.decorators import before_render

class RootController(BaseController):
   @expose('hello.templates.index')
   @before_render(before_render_cb)
	
   def index(self, *args, **kw):
      return dict(page = 'index')

जब एप्लिकेशन को सेवा दी जाती है, तो स्टार्ट अप संदेश कंसोल में प्रदर्शित होता है।

hello, startup world
Starting Standard HTTP server on http://127.0.0.1:8080

जब ब्राउज़र में '/' URL दर्ज किया जाता है, तो कंसोल पर पहले_रेंडर हुक से संबंधित संदेश प्रदर्शित होता है।

system wide before render
Going to render {'page': 'index'}

TurboGears एक्सटेंशन द्वारा पहचाना जाता है tgext.* package। एक गियरबॉक्स टूलकिट नमूना विस्तार बनाने के लिए tgext कमांड प्रदान करता है। उदाहरण के लिए -

gearbox tgext -n myextension

इस आदेश के लिए अन्य वैकल्पिक पैरामीटर हैं -

--author - पैकेज लेखक का नाम।
--email - पैकेज लेखक का ईमेल।
--licence- पैकेज के लिए उपयोग किया जाने वाला लाइसेंस। डिफ़ॉल्ट MIT है।
--description - पैकेज का विवरण।
--keywords - पैकेज कीवर्ड (डिफ़ॉल्ट: turbogears2.extension)।

यह एक tgext.myextension डायरेक्टरी बनाएगा, जिसके अंदर एक साधारण सैंपल एक्सटेंशन है।

Run the setup.py निर्देशिका के अंदर -

Python setup.py install

_init_.py अंदर फ़ाइल करें tgext/myextension फ़ोल्डर में शामिल हैं -

Plugme function - यह विस्तार का प्रवेश बिंदु है।
SetupExtension class - विस्तार इनिशियलाइज़ेशन यहाँ होता है।
On_startup function - क्लास के अंदर क्लास के अंदर __call__ फंक्शन पर पंजीकृत हुक है।

का संक्षिप्त संस्करण tgext\myextension\__init__.py।

from tg import config
from tg import hooks
from tg.configuration import milestones

import logging
log = logging.getLogger('tgext.myextension')

def plugme(configurator, options = None):
   if options is None:
      options = {}
   log.info('Setting up tgext.myextension extension...')
   milestones.config_ready.register(SetupExtension(configurator))
   
   return dict(appid='tgext.myextension')
	
class SetupExtension(object):
   def __init__(self, configurator):
      self.configurator = configurator
      
   def __call__(self):
      log.info('>>> Public files path is %s' % config['paths']['static_files'])
      hooks.register('startup', self.on_startup)
      
   def echo_wrapper_factory(handler, config):
      def echo_wrapper(controller, environ, context):
         log.info('Serving: %s' % context.request.path)
         return handler(controller, environ, context)
      return echo_wrapper
      
   self.configurator.register_wrapper(echo_wrapper_factory)
   
   def on_startup(self):
      log.info('+ Application Running!')

एक बार एक्सटेंशन इंस्टॉल हो जाने के बाद, एप्लिकेशन में निम्न जोड़कर इसे चालू करें app_cfg.py विन्यास फाइल।

from tgext.myextension import plugme

plugme(base_config)

यदि हम गियरबॉक्स सर्वर कमांड का उपयोग करके सर्वर लॉन्च करते हैं, तो एक नए पंजीकृत एक्सटेंशन की सूचना को निम्नलिखित द्वारा कंसोल पर देखा जा सकता है -

14:29:13,250 INFO [tgext.myextension] Setting up tgext.myextension extension...
14:29:13,453 INFO [tgext.myextension] >>> Public files path is c:\tghello\hello\hello\public
14:29:13,453 INFO [tgext.myextension] + Application Running!

Starting Standard HTTP server on http://127.0.0.1:8080

यदि आपके एक्सटेंशन को मॉडल और नियंत्रकों को उजागर करने की आवश्यकता है, तो आप शायद इस पर एक नज़र डालना चाहते हैं Pluggable Applications, जो पुन: प्रयोज्य टर्बोगियर्स एप्लिकेशन बनाने के लिए होते हैं जिन्हें अपनी सुविधाओं का विस्तार करने के लिए अन्य अनुप्रयोगों के अंदर प्लग किया जा सकता है।

प्लगेबल एप्लिकेशन बनाने के लिए निम्न गियरबॉक्स कमांड का उपयोग करें -

gearbox quickstart-pluggable plugtest

ये प्लगेबल एप्लिकेशन अपने स्वयं को परिभाषित कर सकते हैं -

Controllers - जो स्वचालित रूप से माउंट किया जाएगा, जब आवेदन को शुद्ध किया जाता है।
Models - जो प्लग किए गए एप्लिकेशन के अंदर और बाहर उपलब्ध होगा।
Helpers - जिसे एप्लिकेशन टेम्पलेट में 'H' ऑब्जेक्ट में स्वचालित रूप से उजागर किया जा सकता है।
Bootstrap - जिसे सेटअप-ऐप कहा जाने पर निष्पादित किया जाएगा।
Statics - जो उनके निजी मार्ग पर उपलब्ध होगा।

इस प्लगइस्ट एप्लिकेशन को स्थापित करें और निम्नलिखित संशोधनों को करके इसे माउंट करें app_cfg.py।

from tgext.pluggable import plug
plug(base_config, plugtest)

बाकी खड़ा है REप्रस्तुतिकरण Sटेट Transfer। REST वेब मानकों पर आधारित आर्किटेक्चर है और डेटा संचार के लिए HTTP प्रोटोकॉल का उपयोग करता है। यह एक संसाधन के चारों ओर घूमता है जहां हर घटक एक संसाधन होता है और एक संसाधन HTTP मानक विधियों का उपयोग करके एक सामान्य इंटरफ़ेस द्वारा एक्सेस किया जाता है। REST द्वारा पहली बार शुरू किया गया थाRoy Fielding in 2000।

एक RestController क्या है

TurboGears में RestController केवल URL ही नहीं, अनुरोध की विधि तक पहुंचने के लिए एक तंत्र प्रदान करता है। मानक HTTP वर्बेज में शामिल हैं: GET, POST, PUT, और DELETE। RestController इनका समर्थन करता है, और URL प्रेषण के लिए कुछ शॉर्टकट भी जोड़ता है जो डेटा को रूपों और सूचियों के रूप में प्रदर्शित करता है, उपयोगकर्ता के लिए थोड़ा आसान है।

यह समझाने के लिए कि रेस्टफुल टर्बोजियर्स के साथ कैसे काम करता है, हम एक सरल वेबसेवा को परिभाषित करने जा रहे हैं जो छात्रों की सूची को उजागर करती है।

छात्र मॉडल के लिए कोड नीचे दिया गया है -

मॉडल \ student.py

# -* - coding: utf-8 -*-
from sqlalchemy import *

from sqlalchemy.orm import mapper, relation, relation, backref
from sqlalchemy import Table, ForeignKey, Column
from sqlalchemy.types import Integer, Unicode, DateTime
from hello.model import DeclarativeBase, metadata, DBSession
from datetime import datetime

class student(DeclarativeBase):
   __tablename__ = 'student'
   
   uid = Column(Integer, primary_key = True)
   name = Column(Unicode(20), nullable = False, default = '')
   city = Column(Unicode(20), nullable = False, default = '')
   address = Column(Unicode(100), nullable = False, default = '')
   pincode = Column(Unicode(10), nullable = False, default = '')

अब RestController के आधार पर एक नियंत्रक बनाएं और छात्रों को json प्रारूप में सूची देने के लिए एक दृश्य फ़ंक्शन प्रदान करें।

नियंत्रकों \ student.py

from tg import RestController
from tg import expose
from hello import model
from hello.model import DBSession
from hello.model.student import student
from tg.decorators import with_trailing_slash

class StudentController(RestController):
   @expose('json')
   def get_all(self):
      students = DBSession.query(student).all()
      return dict(students=students)

निम्न में निम्नलिखित पंक्तियों को शामिल करके आवेदन के छात्रकंट्रोलर में इस छात्र नियंत्रक को माउंट करें root.py -

from hello.controllers.student import StudentController

class RootController(BaseController):

   students = StudentController()

जा रहा हूँ http://localhost:8080/students यह हमारे छात्रों की सूची json प्रारूप में एन्कोडेड प्रदान करेगा।

हम अपने छात्र को डेटाबेस में सहेजने के बारे में बताने के लिए पोस्ट विधि का उपयोग करते हैं। जब भी इस विधि को बुलाया जाता है http://localhost:8080/student url को POST अनुरोध का उपयोग करके एक्सेस किया जाता है -

@expose('json')
def post(self, name, city, address, pincode):
   newstudent = student(name = name, city = city, address = address, pincode = pincode)
   DBSession.add(newstudent)
   DBSession.flush()
   return dict(student = newstudent)

का उपयोग करते हुए get_one() विधि, हम डेटाबेस से उपयोगकर्ता के लिए एक आइटम प्रदर्शित कर सकते हैं -

@expose('json')
def get_one(self, movie_id):
   newstudent = DBSession.query(student).get(uid)
   return dict(movie = movie)

PUT, REST का उपयोग करके मौजूदा रिकॉर्ड को अपडेट करने के लिए प्रयोग की जाने वाली विधि है -

@expose('json')
def put(self, name = name, city = city, address =  address, pincode = pincode, **kw):
   newstudent = DBSession.query(student).get(name)
   newstudent.name = name
   newstudent.city = city
   newstudent.address = address
   newstudent.pincode = pincode
   return dict(student = newstudent)

डिलीट का काम-घोड़ा पोस्ट_डेली विधि से जुड़ा हुआ है। यहाँ हम वास्तव में डेटाबेस से रिकॉर्ड को हटाते हैं, और फिर सूची पृष्ठ पर वापस भेजते हैं -

@expose('json')
def post_delete(self, uid, **kw):
   newstudent = DBSession.query(student).get(uid)
   DBSession.delete(newstudent)
   return dict(movie = newstudent.uid)

विकास के माहौल से पूर्ण उत्पादन के माहौल पर स्विच करने के लिए, एप्लिकेशन को एक वास्तविक वेब सर्वर पर तैनात करने की आवश्यकता होती है। आपके पास जो कुछ है, उसके आधार पर, टर्बोजियर्स वेब एप्लिकेशन को तैनात करने के लिए विभिन्न विकल्प उपलब्ध हैं।

Mod_wsgi के साथ अपाचे

Mod_wsgi ग्राहम डम्पलटन द्वारा विकसित एक अपाचे मॉड्यूल है। यह WSGI कार्यक्रमों को Apache वेब सर्वर का उपयोग करने की अनुमति देता है।

सबसे पहले, अपाचे 2.X को अपने प्लेटफ़ॉर्म के लिए इंस्टॉल करें, अगर पहले से नहीं किया गया है। एक बार अपाचे को स्थापित करने के बाद, mod_wsgi स्थापित करें। सर्वर पर पायथन वर्चुअल वातावरण बनाएं और सक्रिय करें और इसमें टर्बोजियर्स इंस्टॉल करें।

एप्लिकेशन डायरेक्टर के भीतर अपना एप्लिकेशन इंस्टॉल करें, फिर नाम की स्क्रिप्ट बनाएं app.wsgi।

अपाचे इंस्टॉलेशन को निम्नानुसार कॉन्फ़िगर करें -

<VirtualHost *:80>
   ServerName www.site1.com
   WSGIProcessGroup www.site1.com
   WSGIDaemonProcess www.site1.com user = <username> 
      group = www-data threads = 4 python-path = <pythonpath>
   WSGIScriptAlias myapp/app.wsgi
	
   #Serve static files directly without TurboGears
   Alias /images
   Alias /css
   Alias /js
   CustomLog
   ErrorLog
</VirtualHost>

अपाचे को फिर से शुरू करें

प्रकार http://www.site1.com/ एप्लिकेशन को एक्सेस करने के लिए एक ब्राउज़र पर।

सर्कस और चासेट के तहत टर्बोगियर्स

सर्कस एक प्रक्रिया और सॉकेट प्रबंधक है। इसका उपयोग प्रक्रियाओं और सॉकेट्स की निगरानी और नियंत्रण के लिए किया जा सकता है। जब Chaussette WSGI सर्वर के साथ जोड़ा जाता है, तो यह आपके एप्लिकेशन को परिनियोजित करने और आपके एप्लिकेशन की किसी भी संबंधित प्रक्रिया को प्रबंधित करने के लिए एक शक्तिशाली उपकरण बन सकता है।

TurboGears - GoogleAppEngine

निम्नलिखित URL से पायथन के लिए Google AppEngine SDK इंस्टॉल करें - https://cloud.google.coms

अपने सिस्टम पर Google AppEngine स्थापित करें। फिर Google डेवलपर कंसोल खोलें और अपने Google खाते से साइन इन करें -https://console.developers.google.com/start

नामक एक नई परियोजना बनाएँ mytgapp -

Google AppEngine Launcher का उपयोग करके, एक नया एप्लिकेशन बनाएं जिसका नाम है mytgapp.

निम्नलिखित फाइलें निर्दिष्ट निर्देशिका में बनाई जाएंगी -

app.yaml
favicon.ico
index.yaml
main.py

डिफ़ॉल्ट रूप से, बनाया गया अनुप्रयोग Webapp2 ढांचे पर निर्भर करता है। इस निर्भरता को दूर करने के लिए, app.yaml फ़ाइल को संपादित करें और निम्नलिखित भाग को हटा दें -

libraries:
   - name: webapp2
   version: "2.5.2"

Mytgapp नाम की डायरेक्टरी में एक अस्थाई आभासी वातावरण बनाएं और TurboGears स्थापित करें। इसमें TurboGears एप्लिकेशन बनाएं। अब हम संपादन को आगे बढ़ा सकते हैंmain.py फ़ाइल जो हमारे आवेदन को चलाने के लिए AppEngine द्वारा शुरू की गई है और वास्तव में एक TurboGears आवेदन लिखता है।

में निम्नलिखित सामग्री जोड़ें main.py -

import os
import site
site.addsitedir(os.path.join(os.path.dirname(__file__), 'packages'))
from tg import expose, TGController, AppConfig

class RootController(TGController):
   @expose()
   def index(self):
      return "<h1>Hello World</h1>"
		
config = AppConfig(minimal = True, root_controller = RootController())
app = config.make_wsgi_app()

अब AppEngine Launcher से एप्लिकेशन को चलाएं और ब्राउज़ बटन पर क्लिक करके देखें कि एप्लिकेशन लोकलहोस्ट पर ठीक से काम करता है।

हमने पहले ही डेवलपर कंसोल में mytgapp नाम का एक प्रोजेक्ट बनाया है। अब लॉन्चर में मौजूद तैनाती बटन पर क्लिक करें। तैनाती प्रक्रिया समाप्त होने के बाद,http://mytgapp.appspot.com/ ऑनलाइन हमारे आवेदन को देखने के लिए जाएँ।