Whatever message queue you use, I should warn you that it may very well cause a revolution in your thinking.

మీరు ఏ సందేశ క్యూని ఉపయోగించినా, ఇది మీ ఆలోచనలో విప్లవం కలిగిస్తుందని నేను మీకు హెచ్చరించాలి.


Before you encounter message queues, you tend to consider the function or method call to be the basic mechanism.

మీరు సందేశ క్యూలను ఎదుర్కొనే ముందు, మీరు ఫంక్షన్ లేదా మెథడ్ కాల్‌ను ప్రాథమిక విధానంగా భావిస్తారు.


Once you start using message queues, however, your entire approach toward service architecture may begin to experience a Copernican revolution.

అయితే, మీరు సందేశ క్యూలను ఉపయోగించడం ప్రారంభించిన తర్వాత, సేవా ఆర్కిటెక్చర్ పట్ల మీ మొత్తం విధానం కోపర్నికన్ విప్లవాన్ని అనుభవించడం ప్రారంభించవచ్చు.


The queued message, rather than the library API, will become the fundamental point of rendezvous in your application.

లైబ్రరీ APIకి బదులుగా, క్యూలో ఉన్న సందేశం మీ అప్లికేషన్‌లో సమావేశం యొక్క ప్రాథమిక అంశంగా మారుతుంది.


When all of your application’s work and resources are present within a single address space.

మీ అప్లికేషన్ యొక్క మొత్తం పని మరియు వనరులు ఒకే చిరునామా స్థలంలో ఉన్నప్పుడు.


Message queues also offer resilience and flexibility.

సందేశ క్యూలు స్థితిస్థాపకత మరియు సౌలభ్యాన్ని కూడా అందిస్తాయి.


The HTTPConnection class provided by urllib2 lets you take advantage of this feature.

urllib2 అందించే HTTPConnection తరగతి ఈ ఫీచర్ని ఉపయోగించుకోవడానికి మిమ్మల్ని అనుమతిస్తుంది.


In fact, all requests go through one of these objects.

వాస్తవానికి, అన్ని అభ్యర్థనలు ఈ వస్తువులలో ఒకదాని ద్వారా వెళతాయి.


When you might make several requests to the same site, use a persistent connection instead.

మీరు ఒకే సైట్‌కు చాలా అభ్యర్థనలు చేసినప్పుడు, బదులుగా నిరంతర కనెక్షన్‌ని ఉపయోగించండి.


You can see here that two successive requests are indeed using the same socket object.

ఇక్కడ రెండు వరుస అభ్యర్థనలు నిజంగా ఒకే సాకెట్ వస్తువును ఉపయోగిస్తున్నాయని మీరు చూడవచ్చు.


RFC 2616 does define a header named Connection: that can be used to explicitly indicate that a request is the last one that will be made on a socket.

RFC 2616 కనెక్షన్: అనే పేరుతో ఒక హెడర్‌ను నిర్వచిస్తుంది, ఇది ఒక అభ్యర్థన సాకెట్‌పై చేయబడే చివరిది అని స్పష్టంగా సూచించడానికి ఉపయోగించవచ్చు.


Note that HTTPConnection does not raise an exception when one socket closes and it has to create another one; you can keep using the same object over and over again.

ఒక సాకెట్ మూసివేయబడినప్పుడు మరియు మరొకటి సృష్టించవలసి వచ్చినప్పుడు HTTPConnection మినహాయింపును పెంచదని గమనించండి; మీరు ఒకే వస్తువును పదేపదే ఉపయోగించవచ్చు.


Back in the days of HTTP 1.0 (and earlier), closing the connection was the official way to indicate that the transmission of a document was complete.

HTTP 1.0 (మరియు అంతకు ముందు) రోజుల్లో, కనెక్షన్‌ను మూసివేయడం అనేది డాక్యుమెంట్ ప్రసారం పూర్తయిందని సూచించడానికి అధికారిక మార్గం.


The Content-Length header is so important today largely because it lets the client read several HTTP responses off the same socket without getting confused about where the next response begins.

కంటెంట్-లెంగ్త్ హెడర్ ఈ రోజు చాలా ముఖ్యమైనది, ఎందుకంటే ఇది క్లయింట్ తదుపరి ప్రతిస్పందన ఎక్కడ ప్రారంభమవుతుందో గందరగోళానికి గురికాకుండా ఒకే సాకెట్ నుండి అనేక HTTP ప్రతిస్పందనలను చదవడానికి అనుమతిస్తుంది.


When a length cannot be provided—say, because the server is streaming data whose end it cannot predict ahead of time—then the server can opt to use chunked encoding, where it sends a series of smaller pieces that are each prefixed with their length.

ఒక పొడవును అందించలేనప్పుడు—అంటే, సర్వర్ ముందే ఊహించలేని డేటాను ప్రసారం చేస్తోంది కాబట్టి—అప్పుడు సర్వర్ ముక్కలుగా విభజించబడిన ఎన్‌కోడింగ్‌ను ఉపయోగించవచ్చు, ఇక్కడ అది చిన్న ముక్కల శ్రేణిని పంపుతుంది, ప్రతి ఒక్కటి వాటి పొడవుతో ముందుగా అమర్చబడి ఉంటాయి.


The POST HTTP method was designed to power web forms.

POST HTTP పద్ధతి వెబ్ ఫారమ్‌లకు శక్తినివ్వడానికి రూపొందించబడింది.


But what about a login form that accepts your e-mail address and password?

కానీ మీ ఇమెయిల్ చిరునామా మరియు పాస్‌వర్డ్‌ను అంగీకరించే లాగిన్ ఫారమ్ గురించి ఏమిటి?


The POST method should always be used for forms that are not constructing the name of a particular page or location on a web site, but are instead performing some action on behalf of the caller.

వెబ్‌సైట్‌లో నిర్దిష్ట పేజీ లేదా స్థానం పేరును నిర్మించని ఫారమ్‌ల కోసం POST పద్ధతిని ఎల్లప్పుడూ ఉపయోగించాలి, కానీ బదులుగా కాలర్ తరపున కొన్ని చర్యలను నిర్వహిస్తుంది.


Instead of stuffing form parameters into the URL, a POST carries them in the body of the request.

ఫారమ్ పారామితులను URL లోకి నింపడానికి బదులుగా, POST వాటిని అభ్యర్థన యొక్క శరీరంలో తీసుకువెళుతుంది.


The GET method means, “I believe that there is a document at this URL; please return it.”

GET పద్ధతి అంటే, “ఈ URL వద్ద ఒక పత్రం ఉందని నేను నమ్ముతున్నాను; దయచేసి దానిని తిరిగి ఇవ్వండి.”


The POST method means, “Here is an action that I want performed.”

POST పద్ధతి అంటే, “నేను నిర్వహించాలనుకుంటున్న ఒక చర్య ఇది.”


Note that POST must always be the method used for actions on the Web that have side effects.

వెబ్‌లో సైడ్ ఎఫెక్ట్‌లను కలిగి ఉన్న చర్యల కోసం POSTని ఎల్లప్పుడూ ఉపయోగించాల్సిన పద్ధతి అని గమనించండి.


Successful Form POSTs Should Always Redirect

విజయవంతమైన ఫారమ్ POSTలు ఎల్లప్పుడూ దారి మళ్లించాలి


For all of these reasons, well-designed user-facing POST forms always redirect to a page that shows the result of the action, and this page can be safely bookmarked, shared, stored, and reloaded.

ఈ కారణాలన్నింటికీ, బాగా రూపొందించబడిన వినియోగదారు-ముఖ POST ఫారమ్‌లు ఎల్లప్పుడూ చర్య ఫలితాన్ని చూపించే పేజీకి దారి మళ్లిస్తాయి మరియు ఈ పేజీని సురక్షితంగా బుక్‌మార్క్ చేయవచ్చు, షేర్ చేయవచ్చు, నిల్వ చేయవచ్చు మరియు మళ్లీ లోడ్ చేయవచ్చు.


The one exception is that an unsuccessful POST should immediately display the form again, with its fields already filled out—do not make the user type everything again!—and with their errors or omissions marked, so that the user can correct them.

ఒక మినహాయింపు ఏమిటంటే, విజయవంతం కాని POST వెంటనే ఫారమ్‌ను మళ్లీ ప్రదర్శించాలి, దాని ఫీల్డ్‌లు ఇప్పటికే నింపబడి ఉంటాయి—వినియోగదారుని మళ్లీ ప్రతిదీ టైప్ చేయవద్దు!—మరియు వారి లోపాలు లేదా లోపాలను గుర్తించాలి, తద్వారా వినియోగదారు వాటిని సరిదిద్దవచ్చు.


Almost none of the caveats given in the last two sections apply when an HTTP POST is designed for consumption by a program other than a web browser.

చివరి రెండు విభాగాలలో ఇచ్చిన దాదాపు ఏ హెచ్చరికలు వెబ్ బ్రౌజర్ కాకుండా ప్రోగ్రామ్ ద్వారా వినియోగానికి HTTP POST రూపొందించబడినప్పుడు వర్తించవు.


The program saves the result to phoenix.html.

ప్రోగ్రామ్ ఫలితాన్ని phoenix.htmlకి సేవ్ చేస్తుంది.


We are able to download a forecast page using only a few lines of code.

మేము కొన్ని లైన్ల కోడ్‌ని ఉపయోగించి మాత్రమే ఒక సూచన పేజీని డౌన్‌లోడ్ చేయగలుగుతున్నాము.


The library itself will take responsibility for exploring the HTML and letting you know what forms are present.

HTMLని అన్వేషించడానికి మరియు ఏ ఫారమ్‌లు ఉన్నాయో మీకు తెలియజేయడానికి లైబ్రరీయే బాధ్యత తీసుకుంటుంది.


Here, mechanize has helped us avoid reading any HTML at all.

ఇక్కడ, మెకనైజ్ ఏ HTMLని చదవకుండా ఉండటానికి మాకు సహాయం చేసింది.


We can write a program like that shown in Listing 10–2.

లిస్టింగ్ 10–2లో చూపిన విధంగా మనం ఒక ప్రోగ్రామ్‌ను వ్రాయవచ్చు.


I prefer not to rely on the order, since the real identity of a form is inherent in the action that it performs.

నేను ఆర్డర్‌పై ఆధారపడకూడదనుకుంటున్నాను, ఎందుకంటే ఒక ఫారమ్ యొక్క అసలు గుర్తింపు అది చేసే చర్యలో అంతర్లీనంగా ఉంటుంది.


I avoid using mechanize for simple form submission.

నేను సాధారణ ఫారమ్ సమర్పణ కోసం మెకనైజ్‌ని ఉపయోగించకుండా ఉంటాను.


These web sessions require a visit to the front page anyway.

ఈ వెబ్ సెషన్‌లకు ముందు పేజీని సందర్శించడం అవసరం.


The Hypertext Markup Language (HTML) is one of many markup dialects.

హైపర్టెక్స్ట్ మార్కప్ లాంగ్వేజ్ (HTML) అనేక మార్కప్ మాండలికాలలో ఒకటి.


Inserting bold and italics into a format like HTML is as simple as typing eight angle brackets.

HTML వంటి ఫార్మాట్‌లో బోల్డ్ మరియు ఇటాలిక్‌లను చొప్పించడం ఎనిమిది కోణపు బ్రాకెట్‌లను టైప్ చేయడం అంత సులభం.


Elements can contain text as well as other elements.

మూలకాలు వచనాన్ని అలాగే ఇతర మూలకాలను కలిగి ఉంటాయి.


The problem with SGML languages in this regard is that they expect parsers to know the rules.

ఈ విషయంలో SGML భాషలతో సమస్య ఏమిటంటే, పార్సర్‌లు నియమాలను తెలుసుకోవాలని వారు ఆశిస్తారు.


At first this might look like a series of <li> elements that are more and more deeply nested.

మొదట ఇది లోతుగా అమర్చబడిన <li> మూలకాల శ్రేణిలా కనిపించవచ్చు.


This has resulted not only in a World Wide Web that is full of sites with invalid and broken HTML markup.

దీని ఫలితంగా చెల్లని మరియు విరిగిన HTML మార్కప్‌తో సైట్‌లతో నిండిన వరల్డ్ వైడ్ వెబ్ ఏర్పడింది.


మీరు ఆన్‌లైన్‌లో పుష్కలంగా వనరులను కనుగొనవచ్చు.


We will now turn to that weather forecast for Phoenix, Arizona.

ఇప్పుడు మనం అరిజోనాలోని ఫీనిక్స్ కోసం వాతావరణ సూచన వైపుకు మళ్లుతాము.


Parsing HTML with Python requires three choices.

Pythonతో HTMLని పార్సింగ్ చేయడానికి మూడు ఎంపికలు అవసరం.


The issue of selectors is a very important one.

ఎంపికల సమస్య చాలా ముఖ్యమైనది.


An experienced web developer looking at that list rearranges it in her head.

అనుభవజ్ఞుడైన వెబ్ డెవలపర్ ఆ జాబితాను చూసి తన మనసులో తిరిగి అమర్చుకుంటాడు.


Deep nesting is a very common feature of complicated page designs.

డీప్ నెస్టింగ్ అనేది సంక్లిష్టమైన పేజీ డిజైన్‌ల యొక్క చాలా సాధారణ లక్షణం.


Note that web caches also have to worry about invalidating web resources that are hit by a POST, PUT, or DELETE request because any of those operations could presumably change the data that will be returned to users from that resource.

POST, PUT లేదా DELETE అభ్యర్థన ద్వారా ప్రభావితమయ్యే వెబ్ వనరులను చెల్లనివిగా మార్చడం గురించి వెబ్ కాష్‌లు కూడా ఆందోళన చెందాలి, ఎందుకంటే ఆ కార్యకలాపాలు వినియోగదారులకు తిరిగి వచ్చే డేటాను మార్చవచ్చు.


Caching proxies are tricky things to write and require a vast attention span with respect to reading standards!

కాషింగ్ ప్రాక్సీలను రాయడం కష్టం మరియు ప్రమాణాలను చదవడం విషయంలో చాలా శ్రద్ధ అవసరం!


Neither urllib2 nor mechanize seem to support caching; so if you need a local cache, you might want to look at the httplib2 module available on the Python Package Index.

urllib2 లేదా mechanize రెండూ కాషింగ్‌కు మద్దతు ఇచ్చినట్లు అనిపించదు; కాబట్టి మీకు స్థానిక కాష్ అవసరమైతే, మీరు Python ప్యాకేజీ సూచికలో అందుబాటులో ఉన్న httplib2 మాడ్యూల్‌ను చూడవచ్చు.


In this case, you can issue a HEAD request.

ఈ సందర్భంలో, మీరు HEAD అభ్యర్థనను జారీ చేయవచ్చు.


It’s possible that you might want your program to check a series of links for validity or whether they have moved, but you do not want to incur the expense of actually downloading the body that would follow the HTTP headers.

మీ ప్రోగ్రామ్ లింక్‌ల శ్రేణిని చెల్లుబాటు కోసం లేదా అవి తరలించబడ్డాయో లేదో తనిఖీ చేయాలని మీరు కోరుకోవచ్చు, కానీ HTTP హెడర్‌లను అనుసరించే బాడీని వాస్తవానికి డౌన్‌లోడ్ చేసే ఖర్చును మీరు భరించకూడదనుకుంటున్నారు.


You can see that the body of the response is completely empty.

ప్రతిస్పందన యొక్క బాడీ పూర్తిగా ఖాళీగా ఉందని మీరు చూడవచ్చు.


But the great gulf that Moore’s law has opened between processor speed and the other subsystems on a computer means that there is no reason not to deploy SSL everywhere that user data or identity needs protection.

కానీ కంప్యూటర్‌లోని ప్రాసెసర్ వేగం మరియు ఇతర ఉపవ్యవస్థల మధ్య మూర్స్ లా తెరిచిన గొప్ప లోటు ఏమిటంటే, వినియోగదారు డేటా లేదా గుర్తింపుకు రక్షణ అవసరమయ్యే ప్రతిచోటా SSLని అమలు చేయకపోవడానికి ఎటువంటి కారణం లేదు.


When Google moved its GMail service to being HTTPS-only, the company asserted that the certificate and encryption routines were only adding a few percent to the server CPU usage.

Google తన GMail సేవను HTTPS-మాత్రమేకి మార్చినప్పుడు, సర్టిఫికేట్ మరియు ఎన్‌క్రిప్షన్ రొటీన్‌లు సర్వర్ CPU వినియోగానికి కొన్ని శాతం మాత్రమే జోడిస్తున్నాయని కంపెనీ పేర్కొంది.


An encrypted URL starts with https: instead of simply http:, uses the default port 443 instead of port 80, and uses TLS; review Chapter 6 to remember how TLS/SSL operates.

గుప్తీకరించబడిన URL కేవలం http:కి బదులుగా https:తో ప్రారంభమవుతుంది, పోర్ట్ 80కి బదులుగా డిఫాల్ట్ పోర్ట్ 443ని ఉపయోగిస్తుంది మరియు TLSని ఉపయోగిస్తుంది; TLS/SSL ఎలా పనిచేస్తుందో గుర్తుంచుకోవడానికి అధ్యాయం 6ని సమీక్షించండి.


Encryption places web servers in a dilemma: encryption has to be negotiated before the user can send his HTTP request, lest all of the information in it be divulged; but until the request is transmitted, the server does not know what Host: the request will specify.

గుప్తీకరణ వెబ్ సర్వర్‌లను ఒక సందిగ్ధతలో ఉంచుతుంది: వినియోగదారు తన HTTP అభ్యర్థనను పంపే ముందు గుప్తీకరణను చర్చించాలి, లేకపోతే దానిలోని మొత్తం సమాచారం వెల్లడి చేయబడుతుంది; కానీ అభ్యర్థన ప్రసారం అయ్యే వరకు, అభ్యర్థన ఏ హోస్ట్‌ను పేర్కొంటుందో సర్వర్‌కు తెలియదు.


Therefore, encrypted web sites still live under the old problem of having to use a different IP address for every domain that must be hosted.

అందువల్ల, గుప్తీకరించబడిన వెబ్‌సైట్‌లు హోస్ట్ చేయవలసిన ప్రతి డొమైన్ కోసం వేరే IP చిరునామాను ఉపయోగించాల్సిన పాత సమస్య కింద ఇప్పటికీ జీవిస్తున్నాయి.


A technique known as “Server Name Indication” (SNI) has been developed to get around this traditional restriction; however, Python does not yet support it.

ఈ సాంప్రదాయ పరిమితిని అధిగమించడానికి “సర్వర్ నేమ్ ఇండికేషన్” (SNI) అని పిలువబడే ఒక సాంకేతికత అభివృద్ధి చేయబడింది; అయితే, Python ఇంకా దీనికి మద్దతు ఇవ్వలేదు.


Hopefully, there will be a Python 3 edition of this book within the next year or two that will be able to happily report that SNI is fully supported by urllib2!

ఆశాజనకంగా, రాబోయే ఒకటి లేదా రెండు సంవత్సరాలలో ఈ పుస్తకం యొక్క Python 3 ఎడిషన్ ఉంటుంది, ఇది SNI పూర్తిగా urllib2 ద్వారా మద్దతు ఇవ్వబడుతుందని సంతోషంగా నివేదించగలదు!


To use HTTPS from Python, simply supply an https: method in your URL:

Python నుండి HTTPSని ఉపయోగించడానికి, మీ URLలో https: పద్ధతిని అందించండి:


If the connection works properly, then neither your government nor any of the various large and shadowy corporations that track such things should be able to easily determine either the search term you used or the results you viewed.

కనెక్షన్ సరిగ్గా పని చేస్తే, మీరు ఉపయోగించిన శోధన పదం లేదా మీరు వీక్షించిన ఫలితాలను మీ ప్రభుత్వం లేదా అలాంటి విషయాలను ట్రాక్ చేసే వివిధ పెద్ద మరియు నీడ కార్పొరేషన్‌లలో ఏదీ సులభంగా గుర్తించలేవు.


The HTTP protocol came with a means of authentication that was so poorly thought out and so badly implemented that it seems to have been almost entirely abandoned.

HTTP ప్రోటోకాల్ ప్రామాణీకరణతో వచ్చింది, ఇది చాలా పేలవంగా ఆలోచించబడింది మరియు చాలా చెడ్డగా అమలు చేయబడింది, ఇది దాదాపు పూర్తిగా వదిలివేయబడినట్లు అనిపిస్తుంది.


When a server was asked for a page to which access was restricted, it was supposed to return a response code:

యాక్సెస్ పరిమితం చేయబడిన పేజీని సర్వర్ అడిగినప్పుడు, అది ప్రతిస్పందన కోడ్‌ను తిరిగి ఇవ్వాలి:


This indicated that the server did not know who was requesting the resource, so it could not decide whether to grant permission.

వనరును ఎవరు అభ్యర్థిస్తున్నారో సర్వర్‌కు తెలియదని ఇది సూచిస్తుంది, కాబట్టి అనుమతి ఇవ్వాలా వద్దా అని అది నిర్ణయించలేకపోయింది.


By asking for Basic authentication, the site would induce the web browser to pop up a dialog box asking for a username and password.

ప్రాథమిక ప్రామాణీకరణను అడగడం ద్వారా, సైట్ వెబ్ బ్రౌజర్‌ను వినియోగదారు పేరు మరియు పాస్‌వర్డ్‌ను అడుగుతూ డైలాగ్ బాక్స్ తెరవడానికి ప్రేరేపిస్తుంది.


The authentication token was generated by doing base64 encoding on the colon-separated username and password:

గుర్తింపు ప్రమాణీకరణ టోకెన్ కాలన్-వేరు చేయబడిన వినియోగదారు పేరు మరియు పాస్‌వర్డ్‌పై base64 ఎన్‌కోడింగ్ చేయడం ద్వారా రూపొందించబడింది:


The application handles HTTP requests and uses start_response().

అప్లికేషన్ HTTP అభ్యర్థనలను నిర్వహిస్తుంది మరియు start_response()ని ఉపయోగిస్తుంది.


Generators are useful for loading large files without using much memory.

ఎక్కువ మెమరీని ఉపయోగించకుండా పెద్ద ఫైల్‌లను లోడ్ చేయడానికి జనరేటర్లు ఉపయోగపడతాయి.


The WSGI server concatenates strings to produce the response body.

WSGI సర్వర్ స్పందన బాడీని ఉత్పత్తి చేయడానికి స్ట్రింగ్‌లను కలుపుతుంది.


A 404 error is returned if the URL doesn't match any existing pages.

URL ఏ పేజీతోనూ సరిపోలకపోతే 404 ఎర్రర్ తిరిగి వస్తుంది.


Content types must be correctly paired with documents.

విషయ రకాలు పత్రాలతో సరిగ్గా జత చేయాలి.


User input needs to be meticulously quoted to prevent issues.

సమస్యలను నివారించడానికి వినియోగదారు ఇన్‌పుట్‌ను ఖచ్చితంగా ఉదహరించాలి.


Web frameworks provide tools for handling URLs and user input.

వెబ్ ఫ్రేమ్‌వర్క్‌లు URLలు మరియు వినియోగదారు ఇన్‌పుట్‌ను నిర్వహించడానికి సాధనాలను అందిస్తాయి.


WSGI middleware allows for modifying requests and responses.

WSGI మిడిల్‌వేర్ అభ్యర్థనలు మరియు ప్రతిస్పందనలను సవరించడానికి అనుమతిస్తుంది.


Middleware can delegate requests to the correct application.

మిడిల్‌వేర్ అభ్యర్థనలను సరైన అప్లికేషన్‌కు పంపగలదు.


Authentication can be delegated to WSGI middleware.

గుర్తింపును WSGI మిడిల్‌వేర్‌కు అప్పగించవచ్చు.


Theming can be a problem when combining multiple applications.

బహుళ అప్లికేషన్‌లను కలిపినప్పుడు థీమింగ్ ఒక సమస్య కావచ్చు.


Debuggers can display annotated tracebacks for exceptions.

డీబగ్గర్‌లు మినహాయింపుల కోసం వ్యాఖ్యానించబడిన ట్రేస్‌బ్యాక్‌లను ప్రదర్శించగలవు.


Python web programmers often use web frameworks.

పైథాన్ వెబ్ ప్రోగ్రామర్లు తరచుగా వెబ్ ఫ్రేమ్‌వర్క్‌లను ఉపయోగిస్తారు.


WSGI has not become the standard mechanism for web applications.

WSGI వెబ్ అప్లికేషన్‌ల కోసం ప్రామాణిక విధానంగా మారలేదు.


The WSGI middleware approach uses a component stack.

WSGI మిడిల్‌వేర్ విధానం ఒక భాగాల స్టాక్‌ను ఉపయోగిస్తుంది.


Django is a popular framework for building web sites.

వెబ్‌సైట్‌లను నిర్మించడానికి డిజాంగో ఒక ప్రసిద్ధ ఫ్రేమ్‌వర్క్.


Python 3 has a rigorous approach to byte and Unicode strings.

పైథాన్ 3 బైట్ మరియు యూనికోడ్ స్ట్రింగ్‌లకు కఠినమైన విధానాన్ని కలిగి ఉంది.


Web frameworks help programmers step back from HTTP details.

వెబ్ ఫ్రేమ్‌వర్క్‌లు ప్రోగ్రామర్‌లు HTTP వివరాల నుండి వెనక్కి తగ్గడానికి సహాయపడతాయి.


Templates re-orient our attention in web development.

వెబ్ అభివృద్ధిలో టెంప్లేట్‌లు మన దృష్టిని మళ్ళిస్తాయి.


Choosing a web framework is an important decision.

వెబ్ ఫ్రేమ్‌వర్క్‌ను ఎంచుకోవడం ఒక ముఖ్యమైన నిర్ణయం.


XPath against HTML: by prepending and appending spaces to the class attribute, the selector assures that it can look for the target class name with spaces around it and find a match regardless of where in the list of classes the name falls.

HTML పై XPath: తరగతి లక్షణానికి ఖాళీలను ముందుగా చేర్చడం మరియు జోడించడం ద్వారా, సెలెక్టర్ లక్ష్య తరగతి పేరు చుట్టూ ఖాళీలతో చూసుకోవచ్చని మరియు పేరు తరగతుల జాబితాలో ఎక్కడ ఉన్నా సరిపోతుందని నిర్ధారిస్తుంది.


Selectors, then, can make it simple, elegant, and also quite fast to find elements deep within a document that interest us.

అప్పుడు, సెలెక్టర్లు మనకు ఆసక్తి కలిగించే డాక్యుమెంట్ లోతుల్లోని మూలకాలను కనుగొనడం సులభం, సొగసైనది మరియు చాలా వేగంగా చేయగలవు.


And if they break because the document is redesigned or because of a corner case we did not anticipate, they tend to break in obvious ways, unlike the tedious and deep procedure of walking the document tree that we attempted first.

మరియు డాక్యుమెంట్ ను తిరిగి రూపొందించినందున లేదా మేము ఊహించని మూలన సందర్భం కారణంగా అవి విచ్ఛిన్నమైతే, మేము మొదట ప్రయత్నించిన డాక్యుమెంట్ ట్రీని నడిచే శ్రమతో కూడుకున్న మరియు లోతైన విధానానికి భిన్నంగా, అవి స్పష్టమైన మార్గాల్లో విచ్ఛిన్నమయ్యే అవకాశం ఉంది.


Once you have zeroed in on the part of the document that interests you, it is generally a very simple matter to use the ElementTree or the old BeautifulSoup API to get the text or attribute values you need.

మీకు ఆసక్తి కలిగించే డాక్యుమెంట్ యొక్క భాగాన్ని మీరు గుర్తించిన తర్వాత, మీకు అవసరమైన టెక్స్ట్ లేదా లక్షణ విలువలను పొందడానికి ElementTree లేదా పాత BeautifulSoup APIని ఉపయోగించడం సాధారణంగా చాలా సులభం.


If you are annoyed that the first string did not return as a Unicode object, you will have to blame the ElementTree standard; the glitch has been corrected in Python 3!

మొదటి స్ట్రింగ్ యూనికోడ్ ఆబ్జెక్ట్‌గా తిరిగి రాకపోవడం మీకు చికాకు కలిగిస్తే, మీరు ఎలిమెంట్ ట్రీ ప్రమాణాన్ని నిందించాలి; లోపం Python 3లో సరిదిద్దబడింది!


This can take a bit of getting used to, and works like this: <p> My favorite play is # the <p> element's .text <i> » Hamlet # the <i> element's .text </i> which is not really # the <i> element's .tail <b> » Danish # the <b> element's .text </b> but English.

దీనికి కొంచెం అలవాటు పడవచ్చు మరియు ఇది ఇలా పనిచేస్తుంది: <p> నా అభిమాన నాటకం # <p> మూలకం యొక్క .text <i> » హామ్లెట్ # <i> మూలకం యొక్క .text </i> ఇది నిజంగా కాదు # <i> మూలకం యొక్క .tail <b> » డానిష్ # <b> మూలకం యొక్క .text </b> కానీ ఇంగ్లీష్.


This can be confusing because you would think of the three words favorite and really and English as being at the same “level” of the document—as all being children of the <p> element somehow—but lxml considers only the first word to be part of the text attached to the <p> element, and considers the other two to belong to the tail texts of the inner <i> and <b> elements.

ఇది గందరగోళంగా ఉంటుంది, ఎందుకంటే మీరు మూడు పదాలు ఇష్టమైనవి మరియు నిజంగా మరియు ఇంగ్లీష్ ఒకే “స్థాయి”లో ఉన్నాయని భావిస్తారు—అన్నీ <p> మూలకం యొక్క పిల్లలు—కానీ lxml మొదటి పదాన్ని మాత్రమే <p> మూలకానికి జోడించిన టెక్స్ట్ లో భాగంగా పరిగణిస్తుంది మరియు మిగిలిన రెండింటినీ లోపలి <i> మరియు <b> మూలకాల యొక్క తోక వచనాలకు చెందినవిగా పరిగణిస్తుంది.


BeautifulSoup, by contrast, considers the snippets of text and the <br> elements inside the <font> tag to all be children sitting at the same level of its hierarchy.

దీనికి విరుద్ధంగా, బ్యూటిఫుల్‌సూప్, టెక్స్ట్ ముక్కలు మరియు <font> ట్యాగ్ లోపల ఉన్న <br> మూలకాలను దాని శ్రేణి యొక్క అదే స్థాయిలో కూర్చున్న పిల్లలుగా పరిగణిస్తుంది.


Strings of text, in other words, are treated as phantom elements.

మాటల స్ట్రింగ్‌లను, ఇతర మాటలలో, ఫాంటమ్ మూలకాలుగా పరిగణిస్తారు.


Through a similar operation, we can direct either lxml or BeautifulSoup to the humidity datum.

ఒకే విధమైన ఆపరేషన్ ద్వారా, మనం lxml లేదా బ్యూటిఫుల్‌సూప్‌ను తేమ డేటమ్‌కు నిర్దేశించవచ్చు.


Since the word Humidity: will always occur literally in the document next to the numeric value, this search can be driven by a meaningful term rather than by something as random as the big CSS tag.

తేమ: అనే పదం ఎల్లప్పుడూ సంఖ్యా విలువ పక్కన డాక్యుమెంట్‌లో అక్షరాలా సంభవిస్తుంది కాబట్టి, ఈ శోధన పెద్ద CSS ట్యాగ్ వంటి యాదృచ్ఛికంగా కాకుండా అర్థవంతమైన పదం ద్వారా నడపబడుతుంది.


And here you can see, superbly illustrated, why screen scraping is always an approach of last resort and should always be avoided if you can possibly get your hands on the data some other way: because presentation markup is typically designed for one thing—human readability in browsers—and can vary in crazy ways depending on what it is displaying.

మరియు ఇక్కడ మీరు చూడవచ్చు, అత్యుత్తమంగా వివరించబడింది, స్క్రీన్ స్క్రాపింగ్ ఎల్లప్పుడూ చివరి ఆశ్రయం యొక్క విధానం మరియు మీరు డేటాను మరేదైనా మార్గంలో పొందగలిగితే ఎల్లప్పుడూ నివారించాలి: ఎందుకంటే ప్రెజెంటేషన్ మార్కప్ సాధారణంగా ఒక విషయం కోసం రూపొందించబడింది—బ్రౌజర్‌లలో మానవ రీడబిలిటీ—మరియు ఇది ప్రదర్శించే దానిపై ఆధారపడి పిచ్చి మార్గాల్లో మారవచ్చు.


ఇక్కడ సమస్య ఏమిటి?


A short investigation suggests that the NWS page includes only a <font> element inside of the <tr> if—and this is just a guess of mine, based on a few examples—the description of the current conditions is several words long and thus happens to contain a space.

ఒక చిన్న పరిశోధన NWS పేజీ <tr> లోపల <font> మూలకాన్ని మాత్రమే కలిగి ఉందని సూచిస్తుంది—మరియు ఇది కొన్ని ఉదాహరణలపై ఆధారపడి, నా అంచనా మాత్రమే—ప్రస్తుత పరిస్థితుల వివరణ చాలా పదాలు కలిగి ఉంది మరియు అందువల్ల ఖాళీని కలిగి ఉంటుంది.


The conditions in Phoenix as I have written this chapter are “A Few Clouds,” so the foregoing code has worked just fine; CHAPTER 10 ■ SCREEN SCRAPING 176 but in Springfield, the weather is “Fair” and therefore does not need a <font> wrapper around it, apparently.

నేను ఈ అధ్యాయాన్ని వ్రాసినప్పుడు ఫీనిక్స్ లోని పరిస్థితులు “కొన్ని మేఘాలు,” కాబట్టి మునుపటి కోడ్ బాగా పనిచేసింది; అధ్యాయం 10 ■ స్క్రీన్ స్క్రాపింగ్ 176 కానీ స్ప్రింగ్‌ఫీల్డ్‌లో వాతావరణం “ఫెయిర్”గా ఉంది మరియు అందువల్ల దాని చుట్టూ <font> కవచం అవసరం లేదు.


If you look at the final form of Listing 10–4, you will see a few other tweaks that I made as I noticed changes in format with different cities.

మీరు జాబితా 10–4 యొక్క తుది రూపాన్ని చూస్తే, వివిధ నగరాలతో ఫార్మాట్‌లో మార్పులను గమనించినప్పుడు నేను చేసిన కొన్ని ఇతర మార్పులను మీరు చూస్తారు.


It now seems to work against a reasonable selection of locations; again, note that it gives the same report twice, generated once with lxml and once with BeautifulSoup:

ఇప్పుడు ఇది సహేతుకమైన స్థానాల ఎంపికకు వ్యతిరేకంగా పనిచేస్తున్నట్లు కనిపిస్తుంది; మళ్ళీ, ఇది ఒకే నివేదికను రెండుసార్లు ఇస్తుందని గమనించండి, ఒకసారి lxmlతో మరియు ఒకసారి బ్యూటిఫుల్‌సూప్‌తో రూపొందించబడింది:


You will note that some cities have spaces between the temperature and the F, and others do not.

కొన్ని నగరాల్లో ఉష్ణోగ్రత మరియు F మధ్య ఖాళీలు ఉన్నాయని మీరు గమనించవచ్చు, మరికొన్నిటికి లేవు.


I leave it as an exercise to the reader to determine why the web page currently displays the word “NULL”—you can even see it in the browser—for the temperature in Elk City, Oklahoma.

ఎల్క్ సిటీ, ఓక్లహోమాలోని ఉష్ణోగ్రత కోసం వెబ్ పేజీ ప్రస్తుతం “NULL” అనే పదాన్ని ఎందుకు ప్రదర్శిస్తుందో తెలుసుకోవడానికి నేను పాఠకుడికి ఒక వ్యాయామంగా వదిలివేస్తున్నాను—మీరు దీన్ని బ్రౌజర్‌లో కూడా చూడవచ్చు.


Screen scraping is, at bottom, a complete mess.

స్క్రీన్ స్క్రాపింగ్, దిగువన, పూర్తి గందరగోళం.


The email module in Python can read a message from a file or a string.

పైథాన్ లోని ఇమెయిల్ మాడ్యూల్ ఫైల్ లేదా స్ట్రింగ్ నుండి సందేశాన్ని చదవగలదు.


You can even make adjustments to the message, and then generate a fresh version.

మీరు సందేశానికి సర్దుబాట్లు కూడా చేయవచ్చు, ఆపై కొత్త వెర్షన్‌ను రూపొందించవచ్చు.


ఈ ప్రోగ్రామ్ చిన్నది మరియు సులభమైనది.


For each object it encounters, it checks to see if it is multipart.

అది ఎదుర్కొనే ప్రతి వస్తువు కోసం, అది బహుళ భాగమా కాదా అని తనిఖీ చేస్తుంది.


Individual parts of a message can easily be extracted.

సందేశంలోని వ్యక్తిగత భాగాలను సులభంగా సంగ్రహించవచ్చు.


Fortunately, the email module can decode them all!

అదృష్టవశాత్తూ, ఇమెయిల్ మాడ్యూల్ వాటన్నింటినీ డీకోడ్ చేయగలదు!


This program steps through the message, like the last example.

ఈ ప్రోగ్రామ్ చివరి ఉదాహరణ వలె సందేశం ద్వారా వెళుతుంది.


We skip asking the user about message components that are multipart.

బహుళ భాగాలైన సందేశ భాగాల గురించి వినియోగదారుని అడగడాన్ని మేము దాటవేస్తాము.


When run, the program looks something like this.

రన్ చేసినప్పుడు, ప్రోగ్రామ్ ఇలా కనిపిస్తుంది.


The function decode_header() takes a single header and returns a list of pieces.

decode_header() ఫంక్షన్ ఒకే హెడర్‌ను తీసుకుంటుంది మరియు ముక్కల జాబితాను అందిస్తుంది.


It is always good practice to use decode_header() on any of the “big three” headers.

ఎప్పుడూ “పెద్ద మూడు” శీర్షికలలో దేనిపైనైనా decode_header()ని ఉపయోగించడం మంచిది.


Traditional e-mail messages contain headers and a body.

సాంప్రదాయ ఇమెయిల్ సందేశాలలో శీర్షికలు మరియు బాడీ ఉంటాయి.


Python’s e-mail modules can both generate messages and parse messages.

పైథాన్ యొక్క ఇమెయిల్ మాడ్యూల్స్ సందేశాలను రూపొందించగలవు మరియు సందేశాలను విశ్లేషించగలవు.


To generate a traditional message, an instance of email.mime.text.MIMEText or email.message.Message can be created.

సాంప్రదాయ సందేశాన్ని రూపొందించడానికి, email.mime.text.MIMEText లేదా email.message.Message యొక్క ఉదాహరణను సృష్టించవచ్చు.


MIME is a set of extensions to the e-mail format.

MIME అనేది ఇమెయిల్ ఫార్మాట్‌కు సంబంధించిన పొడిగింపుల సమితి.


Multipart MIME messages can be used for attachments and alternative views.

అటాచ్‌మెంట్‌లు మరియు ప్రత్యామ్నాయ వీక్షణల కోసం బహుళ భాగాల MIME సందేశాలను ఉపయోగించవచ్చు.


The first generations of e-mail users were given usernames and passwords.

మొదటి తరం ఇమెయిల్ వినియోగదారులకు వినియోగదారు పేర్లు మరియు పాస్‌వర్డ్‌లు ఇవ్వబడ్డాయి.


The actual means of bridging this small gap was a mere implementation detail.

ఈ చిన్న అంతరాన్ని తగ్గించే అసలు మార్గం కేవలం అమలు వివరాలు మాత్రమే.


The first widespread e-mail daemon, sendmail, came with a program for submitting e-mail.

మొదటి విస్తృతమైన ఇమెయిల్ డీమన్, sendmail, ఇమెయిల్ సమర్పించడానికి ఒక ప్రోగ్రామ్‌తో వచ్చింది.


The next generation of users were often not familiar with the idea of a command line.

తదుపరి తరం వినియోగదారులు తరచుగా కమాండ్ లైన్ ఆలోచనతో సుపరిచితులు కాదు.


Your Python programs need to send emails.

మీ పైథాన్ ప్రోగ్రామ్‌లు ఇమెయిల్‌లను పంపించాలి.


Successfully sending email often requires a queue.

విజయవంతంగా ఇమెయిల్ పంపడానికి తరచుగా క్యూ అవసరం.


You typically don't want your programs to send mail directly.

మీరు సాధారణంగా మీ ప్రోగ్రామ్‌లు నేరుగా మెయిల్ పంపాలని కోరుకోరు.


Writing a full mail transfer agent is a big job.

పూర్తి మెయిల్ బదిలీ ఏజెంట్‌ను రాయడం ఒక పెద్ద పని.


Take advantage of existing MTAs before writing your own.

మీ స్వంతంగా రాయడానికి ముందు ఇప్పటికే ఉన్న MTAలను ఉపయోగించుకోండి.


Your system administrator might have an opinion on how your program sends mail.

మీ ప్రోగ్రామ్ మెయిల్ ఎలా పంపుతుందో మీ సిస్టమ్ నిర్వాహకుడికి ఒక అభిప్రాయం ఉండవచ్చు.


Make an authenticated SMTP connection to an existing e-mail server.

ఉన్న ఇమెయిల్ సర్వర్‌కు ప్రమాణీకరించబడిన SMTP కనెక్షన్‌ను చేయండి.


Use a username and password for your application.

మీ అప్లికేషన్ కోసం వినియోగదారు పేరు మరియు పాస్‌వర్డ్‌ను ఉపయోగించండి.


Run a local binary like the sendmail program.

sendmail ప్రోగ్రామ్ వంటి స్థానిక బైనరీని అమలు చేయండి.


The addressee headers are not consulted by the SMTP protocol.

SMTP ప్రోటోకాల్ ద్వారా గ్రహీత శీర్షికలను సంప్రదించరు.


The protocol knows only that each message has an envelope.

ప్రతి సందేశానికి ఒక కవరు ఉందని ప్రోటోకాల్‌కు తెలుసు.


The Bcc header names people who you want to receive the mail without other recipients knowing.

Bcc హెడర్ ఇతర గ్రహీతలకు తెలియకుండా మీరు మెయిల్ అందుకోవాలని కోరుకునే వ్యక్తుల పేర్లను కలిగి ఉంటుంది.


Your e-mail client edits your message's headers before sending it.

మీ ఇమెయిల్ క్లయింట్ పంపే ముందు మీ సందేశం యొక్క శీర్షికలను సవరిస్తుంది.


An e-mail can pass across SMTP toward a destination address that is mentioned nowhere in the e-mail headers.

ఇమెయిల్ శీర్షికలలో ఎక్కడా పేర్కొనబడని గమ్యస్థాన చిరునామాకు SMTP ద్వారా ఇమెయిల్ వెళ్ళవచ్చు.


This mechanism also helps support mailing lists.

ఈ విధానం మెయిలింగ్ జాబితాలకు కూడా మద్దతు ఇస్తుంది.


E-mail often travels through multiple servers before reaching its destination.

ఇమెయిల్ తరచుగా గమ్యస్థానానికి చేరుకోవడానికి ముందు బహుళ సర్వర్ల ద్వారా ప్రయాణిస్తుంది.


The SMTP envelope recipient repeatedly changes as the message nears its destination.

సందేశం దాని గమ్యస్థానానికి చేరువవుతున్నప్పుడు SMTP కవరు గ్రహీత పదేపదే మారుతుంది.


E-mail servers are encouraged to write new headers.

ఇమెయిల్ సర్వర్లు కొత్త శీర్షికలను వ్రాయడానికి ప్రోత్సహించబడతాయి.


The smtplib module makes it easy to do simple tasks with SMTP.

smtplib మాడ్యూల్ SMTPతో సాధారణ పనులను చేయడం సులభం చేస్తుంది.


This program uses a very powerful and general function from inside the Standard Library.

ఈ ప్రోగ్రామ్ స్టాండర్డ్ లైబ్రరీ లోపల నుండి చాలా శక్తివంతమైన మరియు సాధారణ ఫంక్షన్‌ను ఉపయోగిస్తుంది.


Python provides an email.utils.formatdate() routine that will generate dates in the right format.

పైథాన్ email.utils.formatdate() అనే రూటీన్‌ను అందిస్తుంది, ఇది సరైన ఫార్మాట్‌లో తేదీలను ఉత్పత్తి చేస్తుంది.


You should add a Message-ID header to messages.

మీరు సందేశాలకు Message-ID శీర్షికను జోడించాలి.


This header should be generated in such a way that no other e-mail, anywhere in history, will ever have the same Message-ID.

చరిత్రలో మరెక్కడా లేని విధంగా, ఏ ఇతర ఇమెయిల్ కూడా అదే Message-IDని కలిగి ఉండకుండా ఈ శీర్షికను రూపొందించాలి.


This might sound difficult, but Python provides a function to help do that as well: email.utils.make_msgid().

ఇది కష్టంగా అనిపించవచ్చు, కానీ పైథాన్ కూడా అలా చేయడానికి సహాయపడే ఒక ఫంక్షన్‌ను అందిస్తుంది: email.utils.make_msgid().


If you run the program, you will notice two new headers in the output.

మీరు ప్రోగ్రామ్‌ను అమలు చేస్తే, అవుట్‌పుట్‌లో రెండు కొత్త శీర్షికలను మీరు గమనించవచ్చు.


సందేశాన్ని పంపడానికి ఇప్పుడు సిద్ధంగా ఉంది!


You might be curious how the unique Message-ID is created.

ప్రత్యేకమైన Message-ID ఎలా సృష్టించబడిందో మీకు ఆసక్తి ఉండవచ్చు.


It is generated by adhering to a set of loose guidelines.

ఇది కొన్ని సడలించిన మార్గదర్శకాలకు అనుగుణంగా ఉత్పత్తి చేయబడుతుంది.


The part to the right of the @ is the full hostname of the machine that is generating the e-mail message.

@ కుడి వైపున ఉన్న భాగం ఇమెయిల్ సందేశాన్ని ఉత్పత్తి చేస్తున్న మెషిన్ యొక్క పూర్తి హోస్ట్ పేరు.


This helps prevent the message ID from being the same as the IDs generated on entirely different computers.

ఇది పూర్తిగా వేర్వేరు కంప్యూటర్‌లలో ఉత్పత్తి చేయబడిన IDల వలె సందేశ ID ఒకేలా ఉండకుండా సహాయపడుతుంది.


The part on the left is typically generated using a combination of the date, time, the process ID of the program generating the message, and some random data.

ఎడమ వైపున ఉన్న భాగం సాధారణంగా తేదీ, సమయం, సందేశాన్ని ఉత్పత్తి చేసే ప్రోగ్రామ్ యొక్క ప్రాసెస్ ID మరియు కొన్ని యాదృచ్ఛిక డేటాను ఉపయోగించి ఉత్పత్తి చేయబడుతుంది.


This combination of data tends to work well in practice in making sure every message can be uniquely identified.

ప్రతి సందేశాన్ని ప్రత్యేకంగా గుర్తించగలదని నిర్ధారించుకోవడానికి ఆచరణలో డేటా యొక్క ఈ కలయిక బాగా పనిచేస్తుంది.


But what happens when you receive an incoming message as a raw block of text and want to look inside?

కానీ మీరు ఇన్‌కమింగ్ సందేశాన్ని ముడి టెక్స్ట్ బ్లాక్‌గా స్వీకరించినప్పుడు మరియు లోపలికి చూడాలనుకున్నప్పుడు ఏమి జరుగుతుంది?


Well, the email module also provides support for parsing e-mail messages, re-constructing the same Message object that would have been used to create the message in the first place.

సరే, ఇమెయిల్ మాడ్యూల్ ఇమెయిల్ సందేశాలను పార్సింగ్ చేయడానికి కూడా మద్దతును అందిస్తుంది, మొదట సందేశాన్ని సృష్టించడానికి ఉపయోగించిన అదే Message వస్తువును తిరిగి నిర్మిస్తుంది.


After parsing the message, you can easily access individual headers and the body of the message using the same conventions as you used to create messages.

సందేశాన్ని పార్స్ చేసిన తర్వాత, మీరు సందేశాలను సృష్టించడానికి ఉపయోగించిన అదే నిబంధనలను ఉపయోగించి వ్యక్తిగత శీర్షికలు మరియు సందేశం యొక్క బాడీని సులభంగా యాక్సెస్ చేయవచ్చు.


headers look like the dictionary key-values of the Message, and the body can be fetched with a function.

శీర్షికలు సందేశం యొక్క నిఘంటువు కీ-విలువలు వలె కనిపిస్తాయి మరియు బాడీని ఒక ఫంక్షన్‌తో పొందవచ్చు.


Like many e-mail clients, this parser distinguishes between the few e-mail headers that users are actually likely to want visible —like From and Subject—and the passel of additional headers that are less likely to interest them.

అనేక ఇమెయిల్ క్లయింట్‌ల వలె, ఈ పార్సర్ వినియోగదారులు నిజంగా కనిపించాలని కోరుకునే కొన్ని ఇమెయిల్ శీర్షికల మధ్య — ఫ్రమ్ మరియు సబ్జెక్ట్ వంటివి — మరియు వారికి ఆసక్తి కలిగించే అవకాశం తక్కువగా ఉన్న అదనపు శీర్షికల మధ్య వ్యత్యాసాన్ని చూపుతుంది.


Here, the “unpopular” Message-ID header, which most users just want hidden, is shown first.

ఇక్కడ, చాలా మంది వినియోగదారులు దాచాలనుకునే “అనాదరణ పొందిన” Message-ID శీర్షిక మొదట చూపబడుతుంది.


Then, the headers actually of interest to the user are printed.

అప్పుడు, వినియోగదారునికి నిజంగా ఆసక్తి కలిగించే శీర్షికలు ముద్రించబడతాయి.


Finally, the body of the e-mail message is displayed on the screen.

చివరగా, ఇమెయిల్ సందేశం యొక్క బాడీ తెరపై ప్రదర్శించబడుతుంది.


If you need specific advanced features such as a Comet-like approach to serving events back to the browser, then you should obviously look for a framework that implements those required features well.

మీకు బ్రౌజర్‌కు ఈవెంట్‌లను అందించడానికి కోమెట్ లాంటి విధానం వంటి నిర్దిష్ట అధునాతన ఫీచర్‌లు అవసరమైతే, ఆ అవసరమైన ఫీచర్‌లను బాగా అమలు చేసే ఫ్రేమ్‌వర్క్‌ను మీరు ఖచ్చితంగా చూడాలి.


Choosing the best tool for the job sometimes involves combining several tools, instead of demanding everything from a single monolithic application.

పని కోసం ఉత్తమ సాధనాన్ని ఎంచుకోవడం కొన్నిసార్లు ఒకే మోనోలిథిక్ అప్లికేషన్ నుండి ప్రతిదీ డిమాండ్ చేయడానికి బదులుగా అనేక సాధనాలను కలపడం కలిగి ఉంటుంది.


Finally, understand that experience is often the best guide to choosing a web framework.

చివరిగా, వెబ్ ఫ్రేమ్‌వర్క్‌ను ఎంచుకోవడానికి అనుభవం తరచుగా ఉత్తమ మార్గదర్శి అని అర్థం చేసుకోండి.


This means that, after all of the window shopping, you are going to have to sit down and try actually writing in some of the various frameworks available before you really know whether a given framework will prove a good fit for either yourself or your problem.

అంటే, అన్ని విండో షాపింగ్ తర్వాత, మీరు కూర్చుని, అందుబాటులో ఉన్న వివిధ ఫ్రేమ్‌వర్క్‌లలో కొన్నింటిలో వాస్తవానికి రాయడానికి ప్రయత్నించాలి, ఇచ్చిన ఫ్రేమ్‌వర్క్ మీకైనా లేదా మీ సమస్యకైనా సరిపోతుందో లేదో మీకు నిజంగా తెలిసే ముందు.


Remember that, whatever framework you choose, you are writing Python code.

మీరు ఏ ఫ్రేమ్‌వర్క్‌ను ఎంచుకున్నా, మీరు పైథాన్ కోడ్‌ను వ్రాస్తున్నారని గుర్తుంచుకోండి.


This means that your application's quality is going to depend at least as much upon your ability to write good, clean, Pythonic code as it will upon any magical features of the framework itself.

అంటే మీ అప్లికేషన్ యొక్క నాణ్యత మంచి, శుభ్రమైన, పైథానిక్ కోడ్‌ను వ్రాయగల మీ సామర్థ్యంపై ఆధారపడి ఉంటుంది, ఇది ఫ్రేమ్‌వర్క్ యొక్క మాయా లక్షణాలపై ఆధారపడి ఉంటుంది.


The framework might even feel rather awkward to you, or it might be selected by a senior team member with whom you disagree; but always remember that this is Python, and that its flexibility and elegance will generally let you write a good web application, whatever framework you ultimately end up using.

ఫ్రేమ్‌వర్క్ మీకు కొంచెం ఇబ్బందికరంగా అనిపించవచ్చు లేదా మీరు విభేదించే సీనియర్ టీమ్ సభ్యుడు దీన్ని ఎంచుకోవచ్చు; కానీ ఇది పైథాన్ అని మరియు దాని సౌలభ్యం మరియు చక్కదనం సాధారణంగా మీరు మంచి వెబ్ అప్లికేషన్‌ను వ్రాయడానికి వీలు కల్పిస్తుందని ఎల్లప్పుడూ గుర్తుంచుకోండి, మీరు చివరికి ఏ ఫ్రేమ్‌వర్క్‌ను ఉపయోగిస్తున్నా.


A fun way to demonstrate that Python comes with “batteries included” is to enter a directory on your system and run the SimpleHTTPServer Standard Library module as a stand-alone program.

పైథాన్ “బ్యాటరీలతో వస్తుంది” అని నిరూపించడానికి ఒక సరదా మార్గం ఏమిటంటే, మీ సిస్టమ్‌లోని డైరెక్టరీని నమోదు చేసి, సింపుల్‌హెచ్‌టిటిపిసర్వర్ స్టాండర్డ్ లైబ్రరీ మాడ్యూల్‌ను స్వతంత్ర ప్రోగ్రామ్‌గా అమలు చేయడం.


If you direct your browser to localhost:8000, you will see the contents of this script's current directory displayed for browsing, such as the listings provided by Apache when a site leaves a directory browsable.

మీరు మీ బ్రౌజర్‌ను localhost:8000కి మళ్లించినట్లయితే, మీరు బ్రౌజింగ్ కోసం ఈ స్క్రిప్ట్ యొక్క ప్రస్తుత డైరెక్టరీలోని విషయాలను చూస్తారు, ఉదాహరణకు, ఒక సైట్ డైరెక్టరీని బ్రౌజ్ చేయడానికి వదిలివేసినప్పుడు అపాచీ అందించిన జాబితాలు.


Documents and images will load in your web browser when selected, based on the content types chosen through the best guesses of the mimetypes Standard Library module.

మీరు ఎంచుకున్నప్పుడు డాక్యుమెంట్‌లు మరియు చిత్రాలు మీ వెబ్ బ్రౌజర్‌లో లోడ్ అవుతాయి, mimetypes స్టాండర్డ్ లైబ్రరీ మాడ్యూల్ యొక్క ఉత్తమ అంచనాల ద్వారా ఎంచుకున్న కంటెంట్ రకాల ఆధారంగా.


The SimpleHTTPServer is a subclass of BaseHTTPServer, which is also the foundation of the wsgiref.simple_server that we looked at earlier.

సింపుల్‌హెచ్‌టిటిపిసర్వర్ అనేది బేస్‌హెచ్‌టిటిపిసర్వర్ యొక్క ఉపవర్గం, ఇది మనం ఇంతకు ముందు చూసిన wsgiref.simple_server యొక్క ఆధారం కూడా.


Before the WSGI standard was invented, small Python programs could subclass BaseHTTPServer if they needed to answer raw HTTP requests.

WSGI ప్రమాణం కనుగొనబడటానికి ముందు, చిన్న పైథాన్ ప్రోగ్రామ్‌లు ముడి HTTP అభ్యర్థనలకు సమాధానం ఇవ్వవలసి వస్తే బేస్‌హెచ్‌టిటిపిసర్వర్‌ను ఉపవర్గం చేయగలవు.


This is actually a common difference between the old mechanisms by which Python programs provided extensibility, and the more modern and Pythonic mechanisms.

పైథాన్ ప్రోగ్రామ్‌లు విస్తరణను అందించే పాత విధానాలు మరియు మరింత ఆధునిక మరియు పైథానిక్ విధానాల మధ్య ఇది వాస్తవానికి ఒక సాధారణ వ్యత్యాసం.


It used to be popular to write a class with stub methods inside, and then tell programmers to extend it by subclassing and defining those methods; today, we use namespaces, callables, and duck-typed objects to provide much cleaner forms of extensibility.

ఒక తరగతిని లోపల స్టబ్ పద్ధతులతో రాయడం మరియు ప్రోగ్రామర్‌లను సబ్‌క్లాసింగ్ చేయడం మరియు ఆ పద్ధతులను నిర్వచించడం ద్వారా విస్తరించమని చెప్పడం ఒకప్పుడు ప్రసిద్ధి చెందింది; నేడు, మేము విస్తరణ యొక్క చాలా శుభ్రమైన రూపాలను అందించడానికి నేమ్‌స్పేస్‌లు, కాల్‌బుల్స్ మరియు డక్-టైప్ చేసిన వస్తువులను ఉపయోగిస్తాము.


For example, today an object like start_response is provided as an argument (dependency injection), and the WSGI standard specifies its behavior rather than its inheritance tree (duck typing).

ఉదాహరణకు, నేడు start_response వంటి ఒక వస్తువు ఒక వాదనగా అందించబడుతుంది (ఆధారపడటం ఇంజెక్షన్), మరియు WSGI ప్రమాణం దాని వారసత్వ వృక్షానికి బదులుగా దాని ప్రవర్తనను పేర్కొంటుంది (డక్ టైపింగ్).


The Standard Library includes two other HTTP servers: CGIHTTPServer takes the SimpleHTTPServer and, instead of just serving static files off of the disk, it adds the ability to run CGI scripts (which we will cover in the next section).

ప్రామాణిక లైబ్రరీలో మరో రెండు HTTP సర్వర్లు ఉన్నాయి: CGIHTTPServer సింపుల్‌హెచ్‌టిటిపిసర్వర్‌ను తీసుకుంటుంది మరియు డిస్క్ నుండి స్టాటిక్ ఫైల్‌లను అందించడానికి బదులుగా, ఇది CGI స్క్రిప్ట్‌లను అమలు చేసే సామర్థ్యాన్ని జోడిస్తుంది (దీనిని మనం తదుపరి విభాగంలో కవర్ చేస్తాము).


SimpleXMLRPCServer and DocXMLRPCServer each provide a server endpoint against which client programs can make XML-RPC remote procedure calls, as demonstrated in Chapter 18 and Listing 22-1.

సింపుల్‌ఎక్స్‌ఎంఎల్‌ఆర్‌పిసిసర్వర్ మరియు డాక్స్‌ఎంఎల్‌ఆర్‌పిసిసర్వర్ రెండూ ఒక సర్వర్ ఎండ్‌పాయింట్‌ను అందిస్తాయి, దీనికి వ్యతిరేకంగా క్లయింట్ ప్రోగ్రామ్‌లు చాప్టర్ 18 మరియు జాబితా 22-1లో చూపిన విధంగా XML-RPC రిమోట్ విధాన కాల్‌లను చేయవచ్చు.


Note that none of the preceding servers is typically intended for production use; instead, they are useful for small internal tasks for which you just need a quick HTTP endpoint to be used by other services internal to a system or subnet.

మునుపటి సర్వర్లలో ఏదీ సాధారణంగా ఉత్పత్తి వినియోగానికి ఉద్దేశించబడలేదని గమనించండి; బదులుగా, సిస్టమ్ లేదా సబ్‌నెట్‌కు అంతర్గతంగా ఉన్న ఇతర సేవల ద్వారా ఉపయోగించబడే శీఘ్ర HTTP ఎండ్‌పాయింట్ మీకు అవసరమైన చిన్న అంతర్గత పనులకు అవి ఉపయోగపడతాయి.


And while most Python web frameworks will provide a way to run your application from the command line for debugging, most follow the lead of Django in recommending against using the development platform for debugging.

మరియు చాలా పైథాన్ వెబ్ ఫ్రేమ్‌వర్క్‌లు డీబగ్గింగ్ కోసం కమాండ్ లైన్ నుండి మీ అప్లికేషన్‌ను అమలు చేయడానికి ఒక మార్గాన్ని అందిస్తుండగా, చాలా మంది డీబగ్గింగ్ కోసం అభివృద్ధి ప్లాట్‌ఫారమ్‌ను ఉపయోగించకుండా సిఫార్సు చేయడంలో జాంగోను అనుసరిస్తారు.


However, a few Python web frameworks exist that not only provide their own built-in HTTP servers, but have also worked on their security and performance, so that they can be recommended for use in production.

అయితే, కొన్ని పైథాన్ వెబ్ ఫ్రేమ్‌వర్క్‌లు ఉన్నాయి, ఇవి వాటి స్వంత అంతర్నిర్మిత HTTP సర్వర్‌లను అందించడమే కాకుండా, వాటి భద్రత మరియు పనితీరుపై కూడా పని చేశాయి, తద్వారా వాటిని ఉత్పత్తిలో ఉపయోగించడానికి సిఫార్సు చేయవచ్చు.


If not, then the remote server does not support TLS and the message can only be sent normally, in the clear.

అలా కాకపోతే, రిమోట్ సర్వర్ TLSకు మద్దతు ఇవ్వదు మరియు సందేశాన్ని సాధారణంగా, స్పష్టంగా మాత్రమే పంపవచ్చు.


Call starttls() to initiate the encrypted channel.

గుప్తీకరించబడిన ఛానెల్‌ను ప్రారంభించడానికి starttls()ని కాల్ చేయండి.


Call ehlo() a second time; this time, it’s encrypted.

రెండవసారి ehlo()ని కాల్ చేయండి; ఈసారి, ఇది గుప్తీకరించబడింది.


చివరిగా, మీ సందేశాన్ని పంపండి.


The first question you have to ask yourself when working with TLS is whether you should return an error if TLS is not available.

TLSతో పని చేస్తున్నప్పుడు మీరు మిమ్మల్ని మీరు ప్రశ్నించుకోవలసిన మొదటి ప్రశ్న ఏమిటంటే, TLS అందుబాటులో లేకపోతే మీరు లోపాన్ని తిరిగి ఇవ్వాలా వద్దా?


Depending on your application, you might want to raise an error for any of the following:

మీ అప్లికేషన్‌ను బట్టి, మీరు కింది వాటిలో దేనికైనా లోపాన్ని పెంచవచ్చు:


There is no support for TLS on the remote side.

రిమోట్ వైపు TLSకి మద్దతు లేదు.


The remote side fails to establish a TLS session properly.

రిమోట్ వైపు TLS సెషన్‌ను సరిగ్గా ఏర్పాటు చేయడంలో విఫలమవుతుంది.


The remote server presents a certificate that cannot be validated.

రిమోట్ సర్వర్ ధృవీకరించలేని సర్టిఫికేట్‌ను అందిస్తుంది.


Let us step through each of these scenarios and see when they may deserve an error message.

ఈ దృశ్యాలలో ప్రతి ఒక్కటి ద్వారా వెళ్దాం మరియు అవి ఎప్పుడు లోపం సందేశానికి అర్హత పొందుతాయో చూద్దాం.


First, it is sometimes appropriate to treat a lack of support for TLS altogether as an error.

ముందుగా, TLSకి మద్దతు లేకపోవడాన్ని మొత్తం లోపంగా పరిగణించడం కొన్నిసార్లు సముచితం.


This could be the case if you are writing an application that speaks to only a limited set of mail servers—perhaps mail servers run by your company that you know should support TLS, or mail servers run by a bank that you know supports TLS.

మీరు పరిమిత సంఖ్యలో మెయిల్ సర్వర్‌లకు మాత్రమే మాట్లాడే అప్లికేషన్‌ను వ్రాస్తుంటే ఇది కావచ్చు— బహుశా మీ కంపెనీ నడుపుతున్న మెయిల్ సర్వర్‌లు TLSకి మద్దతు ఇవ్వాలని మీకు తెలుసు లేదా TLSకి మద్దతు ఇస్తుందని మీకు తెలిసిన బ్యాంకు నడుపుతున్న మెయిల్ సర్వర్‌లు.


But since only a minority of mail servers on the Internet today support TLS, a mail program should not, in general, treat its absence as an error.

కానీ నేడు ఇంటర్నెట్‌లో చాలా తక్కువ సంఖ్యలో మెయిల్ సర్వర్‌లు TLSకి మద్దతు ఇస్తున్నందున, సాధారణంగా మెయిల్ ప్రోగ్రామ్ దాని లేకపోవడాన్ని లోపంగా పరిగణించకూడదు.


Many TLS-aware SMTP clients will use TLS if available, but will fall back on standard, unsecured transmission otherwise.

అనేక TLS-అవేర్ SMTP క్లయింట్‌లు అందుబాటులో ఉంటే TLSని ఉపయోగిస్తాయి, కానీ లేకపోతే ప్రామాణిక, సురక్షితం కాని ప్రసారంపై పడిపోతాయి.


This is known as opportunistic encryption and is less secure than forcing all communications to be encrypted, but protects messages when the capability is present.

దీనిని అవకాశవాద ఎన్‌క్రిప్షన్ అంటారు మరియు అన్ని కమ్యూనికేషన్‌లను గుప్తీకరించమని బలవంతం చేయడం కంటే తక్కువ సురక్షితం, కానీ సామర్థ్యం ఉన్నప్పుడు సందేశాలను రక్షిస్తుంది.


Second, sometimes a remote server claims to be TLS-aware but then fails to properly establish a TLS connection.

రెండవది, కొన్నిసార్లు రిమోట్ సర్వర్ TLS-అవేర్ అని పేర్కొంటుంది, కానీ TLS కనెక్షన్‌ను సరిగ్గా ఏర్పాటు చేయడంలో విఫలమవుతుంది.


This is often due to a misconfiguration on the server’s end.

ఇది తరచుగా సర్వర్ ముగింపులో తప్పు కాన్ఫిగరేషన్ కారణంగా జరుగుతుంది.


To be as robust as possible, you may wish to retry your transmission to such a server with a new connection that you do not even try to encrypt.

వీలైనంత దృఢంగా ఉండటానికి, మీరు గుప్తీకరించడానికి కూడా ప్రయత్నించని కొత్త కనెక్షన్‌తో అలాంటి సర్వర్‌కు మీ ప్రసారాన్ని మళ్లీ ప్రయత్నించాలని కోరుకోవచ్చు.


Third, there is the situation where you cannot completely authenticate the remote server.

మూడవది, మీరు రిమోట్ సర్వర్‌ను పూర్తిగా ప్రామాణీకరించలేని పరిస్థితి ఉంది.


If your security policy dictates that you must exchange mail only with trusted servers, then lack of authentication is clearly a problem warranting an error message; but for a general-purpose client, it probably merits a warning instead.

మీ భద్రతా విధానం మీరు విశ్వసనీయ సర్వర్‌లతో మాత్రమే మెయిల్ మార్పిడి చేయాలని నిర్దేశిస్తే, అప్పుడు ప్రమాణీకరణ లేకపోవడం స్పష్టంగా లోపం సందేశానికి హామీ ఇచ్చే సమస్య; కానీ సాధారణ ప్రయోజన క్లయింట్ కోసం, బదులుగా ఇది బహుశా హెచ్చరికకు అర్హత పొందుతుంది.


ప్రోగ్రామ్ ముగుస్తోంది.


Programs change their behavior when talking to a terminal.

టెర్మినల్‌తో మాట్లాడేటప్పుడు ప్రోగ్రామ్‌లు వాటి ప్రవర్తనను మారుస్తాయి.


The Unix terminal defaults to “canonical” input processing.

యూనిక్స్ టెర్మినల్ “కెనానికల్” ఇన్పుట్ ప్రాసెసింగ్‌కు డిఫాల్ట్ అవుతుంది.


You can use the stty command to disable it.

మీరు దీన్ని నిలిపివేయడానికి stty కమాండ్ ఉపయోగించవచ్చు.


Unix terminals traditionally supported a pair of keystrokes for pausing the output stream.

యూనిక్స్ టెర్మినల్స్ సాంప్రదాయకంగా అవుట్‌పుట్ స్ట్రీమ్‌ను పాజ్ చేయడానికి కొన్ని కీస్ట్రోక్‌లను సపోర్ట్ చేస్తాయి.


This setting can be turned off with stty.

ఈ సెట్టింగ్‌ను sttyతో ఆఫ్ చేయవచ్చు.


Because there are so many settings, the stty command supports two modes.

అనేక సెట్టింగ్‌లు ఉన్నందున, stty కమాండ్ రెండు మోడ్‌లకు మద్దతు ఇస్తుంది.


Most Unix systems provide a command for resetting the terminal.

చాలా యూనిక్స్ సిస్టమ్‌లు టెర్మినల్‌ను రీసెట్ చేయడానికి ఒక కమాండ్‌ను అందిస్తాయి.


Check out the termios module that comes with the Standard Library.

ప్రామాణిక లైబ్రరీతో వచ్చే టెర్మియోస్ మాడ్యూల్‌ను చూడండి.


టెల్నెట్ సురక్షితం కాదు.


Anyone watching your Telnet packets will see your username and password.

మీ టెల్నెట్ ప్యాకెట్‌లను చూసే ఎవరైనా మీ వినియోగదారు పేరు మరియు పాస్‌వర్డ్‌ను చూస్తారు.


జాబితా 16–3 localhostకి కనెక్ట్ అవుతుంది.


The listing shows you the general structure of a session powered by telnetlib.

టెల్నెట్‌లిబ్ ద్వారా నడిచే సెషన్ యొక్క సాధారణ నిర్మాణాన్ని జాబితా మీకు చూపుతుంది.


You can call set_debuglevel(1) if you want your Telnet object to print out all of the strings.

మీరు మీ టెల్నెట్ ఆబ్జెక్ట్ అన్ని స్ట్రింగ్‌లను ప్రింట్ చేయాలనుకుంటే, మీరు set_debuglevel(1)ని కాల్ చేయవచ్చు.


Telnet does not disguise the fact that its service is backed by a TCP socket.

టెల్నెట్ దాని సేవ TCP సాకెట్ ద్వారా మద్దతు ఇవ్వబడుతుందనే వాస్తవాన్ని దాచదు.


Interaction generally falls into a receive-and-send pattern.

పరస్పర చర్య సాధారణంగా స్వీకరించడం మరియు పంపడం నమూనాలోకి వస్తుంది.


The read_until() method watches for a literal string to arrive.

read_until() పద్ధతి అక్షర స్ట్రింగ్ రావడానికి చూస్తుంది.


The expect() method takes a list of Python regular expressions.

expect() పద్ధతి పైథాన్ రెగ్యులర్ ఎక్స్‌ప్రెషన్స్ జాబితాను తీసుకుంటుంది.


Regular expressions, as always, have to be written carefully.

రెగ్యులర్ ఎక్స్‌ప్రెషన్స్, ఎల్లప్పుడూ వలె, జాగ్రత్తగా వ్రాయాలి.


If you wind up writing a Python script that has to use Telnet, it will simply be a larger or more complicated version.

మీరు టెల్నెట్‌ను ఉపయోగించాల్సిన పైథాన్ స్క్రిప్ట్‌ను వ్రాస్తే, అది కేవలం పెద్ద లేదా మరింత సంక్లిష్టమైన వెర్షన్ అవుతుంది.


The IMAPClient package is written by a friendly Python programmer named Menno Smits.

IMAPClient ప్యాకేజీని మెన్నో స్మిట్స్ అనే స్నేహపూర్వక పైథాన్ ప్రోగ్రామర్ రాశారు.


If you want to try out IMAPClient, try installing it in a “virtualenv.”

మీరు IMAPClientని ప్రయత్నించాలనుకుంటే, దానిని “virtualenv”లో ఇన్‌స్టాల్ చేయడానికి ప్రయత్నించండి.


You can see immediately from the code that more details of the protocol exchange are now being handled on our behalf.

ప్రోటోకాల్ మార్పిడికి సంబంధించిన మరిన్ని వివరాలు ఇప్పుడు మన తరపున నిర్వహించబడుతున్నాయని కోడ్ నుండి మీరు వెంటనే చూడవచ్చు.


For example, we no longer get a status code back that we have to check every time we run a command.

ఉదాహరణకు, మనం ఇకపై ప్రతిసారీ ఒక కమాండ్ రన్ చేసినప్పుడు తనిఖీ చేయవలసిన స్టేటస్ కోడ్‌ను తిరిగి పొందలేము.


Each line of data comes back as a tuple giving us the folder flags, folder name delimiter, and folder name, and the flags themselves are a sequence of strings.

డేటా యొక్క ప్రతి లైన్ మనకు ఫోల్డర్ ఫ్లాగ్‌లు, ఫోల్డర్ పేరు డిలిమిటర్ మరియు ఫోల్డర్ పేరును అందిస్తూ ఒక టపుల్‌గా తిరిగి వస్తుంది మరియు ఫ్లాగ్‌లు స్ట్రింగ్‌ల శ్రేణి.


This means that the folder does not contain any sub-folders and that it is not possible for it to contain sub-folders in the future.

అంటే ఫోల్డర్‌లో సబ్-ఫోల్డర్‌లు ఏవీ లేవు మరియు భవిష్యత్తులో సబ్-ఫోల్డర్‌లను కలిగి ఉండటం సాధ్యం కాదు.


This means that it is not possible to run select_folder() on this folder—that is, this folder does not and cannot contain any messages.

అంటే ఈ ఫోల్డర్‌లో select_folder()ని అమలు చేయడం సాధ్యం కాదు—అంటే, ఈ ఫోల్డర్‌లో సందేశాలు ఉండవు మరియు కలిగి ఉండలేవు.


This means that the server considers this box to be interesting in some way; generally, this indicates that new messages have been delivered since the last time the folder was selected.

అంటే సర్వర్ ఈ పెట్టెను ఏదో ఒక విధంగా ఆసక్తికరంగా పరిగణిస్తుంది; సాధారణంగా, చివరిసారి ఫోల్డర్‌ను ఎంచుకున్నప్పటి నుండి కొత్త సందేశాలు డెలివరీ చేయబడ్డాయని ఇది సూచిస్తుంది.


Your code must be able to accept and ignore those additional flags.

మీ కోడ్ ఆ అదనపు ఫ్లాగ్‌లను అంగీకరించగలగాలి మరియు విస్మరించగలగాలి.


This can make interaction more pleasant, but it also means that your program has to be careful that it always knows what folder is selected.

ఇది పరస్పర చర్యను మరింత ఆహ్లాదకరంగా చేస్తుంది, కానీ మీ ప్రోగ్రామ్ ఎల్లప్పుడూ ఏ ఫోల్డర్ ఎంచుకోబడిందో తెలుసుకోవడానికి జాగ్రత్తగా ఉండాలి.


When selecting, you have the option to select the folder “read only” by supplying a readonly=True argument.

ఎంచుకున్నప్పుడు, readonly=True వాదనను అందించడం ద్వారా ఫోల్డర్‌ను “రీడ్ ఓన్లీ” ఎంచుకునే అవకాశం మీకు ఉంది.


Message numbers are assigned right when you select the folder.

మీరు ఫోల్డర్‌ను ఎంచుకున్న వెంటనే సందేశ సంఖ్యలు కేటాయించబడతాయి.


But a UID, by contrast, is designed to remain the same even if you close your connection to the server and do not reconnect again for another week.

కానీ, దీనికి విరుద్ధంగా, UID మీరు సర్వర్‌కు మీ కనెక్షన్‌ను మూసివేసినా మరియు మరొక వారం పాటు మళ్లీ కనెక్ట్ కాకపోయినా ఒకే విధంగా ఉండేలా రూపొందించబడింది.


If you are writing a synchronization tool, this behavior is quite useful!

మీరు సమకాలీకరణ సాధనాన్ని వ్రాస్తుంటే, ఈ ప్రవర్తన చాలా ఉపయోగకరంగా ఉంటుంది!


Most IMAP commands that work with specific messages can take either message numbers or UIDs.

నిర్దిష్ట సందేశాలతో పనిచేసే చాలా IMAP ఆదేశాలు సందేశ సంఖ్యలు లేదా UIDs తీసుకోవచ్చు.


When you supply a message number, you can instead supply a comma-separated list of message numbers.

మీరు సందేశ సంఖ్యను అందించినప్పుడు, మీరు కామాతో వేరు చేయబడిన సందేశ సంఖ్యల జాబితాను అందించవచ్చు.


An asterisk means “and all of the rest of the messages.”

నక్షత్రం గుర్తు “మరియు మిగిలిన అన్ని సందేశాలు” అని అర్థం.


The summary is returned by IMAPClient as a dictionary.

సారాంశం IMAPClient ద్వారా నిఘంటువుగా తిరిగి ఇవ్వబడుతుంది.


Remember to compare the UIDVALIDITY to a stored value from a previous session.

మునుపటి సెషన్ నుండి నిల్వ చేసిన విలువతో UIDVALIDITYని సరిపోల్చాలని గుర్తుంచుకోండి.


While this is simplest and requires the least network traffic, it does mean that all of the returned messages will need to sit in memory together.

ఇది చాలా సులభమైనది మరియు తక్కువ నెట్‌వర్క్ ట్రాఫిక్‌ను కలిగి ఉంటుంది, అంటే తిరిగి వచ్చిన అన్ని సందేశాలు మెమరీలో కలిసి ఉండాలి.


Once the user has selected a particular message, we use a technique that we have not discussed so far.

ఒకసారి వినియోగదారుడు ఒక నిర్దిష్ట సందేశాన్ని ఎంచుకున్న తర్వాత, మేము ఇంతకు ముందు చర్చించని ఒక పద్ధతిని ఉపయోగిస్తాము.


Instead of making us pull several megabytes over the network just to list a large message’s attachments, BODYSTRUCTURE simply lists its MIME sections as a recursive data structure.

ఒక పెద్ద సందేశం యొక్క జోడింపులను జాబితా చేయడానికి మాత్రమే నెట్‌వర్క్ ద్వారా అనేక మెగాబైట్‌లను లాగడానికి బదులుగా, BODYSTRUCTURE దాని MIME విభాగాలను పునరావృత డేటా నిర్మాణంగా జాబితా చేస్తుంది.


Simple MIME parts are returned as a tuple: ('TEXT', 'PLAIN', ('CHARSET', 'US-ASCII'), None, None, '7BIT', 2279, 48)

సాధారణ MIME భాగాలు ఒక ట్యూపుల్‌గా తిరిగి ఇవ్వబడతాయి: ('TEXT', 'PLAIN', ('CHARSET', 'US-ASCII'), None, None, '7BIT', 2279, 48)


The elements of this tuple, which are detailed in section 7.4.2 of RFC 3501, are as follows (starting from item index zero, of course):

RFC 3501 యొక్క విభాగం 7.4.2 లో వివరంగా ఉన్న ఈ ట్యూపుల్ యొక్క అంశాలు ఈ క్రింది విధంగా ఉన్నాయి (అంశ సూచిక సున్నా నుండి ప్రారంభించి, కోర్సులో):


When the IMAP server sees that a message is multipart, or when it examines one of the parts of the message that it discovers is itself multipart, then the tuple it returns will begin with a list of sub-structures.

IMAP సర్వర్ ఒక సందేశం బహుళ భాగమని చూసినప్పుడు లేదా అది కనుగొన్న సందేశంలోని భాగాలలో ఒకదానిని పరిశీలించినప్పుడు అది కూడా బహుళ భాగమని, అప్పుడు అది తిరిగి ఇచ్చే ట్యూపుల్ ఉప-నిర్మాణాల జాబితాతో ప్రారంభమవుతుంది.


The value "MIXED" indicates exactly what kind of multipart container is being represented—in this case, the full type is multipart/mixed.

"MIXED" విలువ ఏ రకమైన బహుళ భాగాల కంటైనర్ సూచించబడుతుందో ఖచ్చితంగా సూచిస్తుంది - ఈ సందర్భంలో, పూర్తి రకం బహుళ భాగం/మిశ్రమంగా ఉంటుంది.


Other common “multipart” subtypes besides “mixed” are alternative, digest, and parallel.

"మిశ్రమ"తో పాటు ఇతర సాధారణ "బహుళ భాగం" ఉప రకాలు ప్రత్యామ్నాయం, డైజెస్ట్ మరియు సమాంతరంగా ఉన్నాయి.


Given these rules, you can see how a recursive routine like display_structure() in Listing 15–7 is perfect for unwinding and displaying the hierarchy of parts in a message.

ఈ నియమాలను బట్టి, జాబితా 15–7లో display_structure() వంటి పునరావృత దినచర్య సందేశంలోని భాగాల శ్రేణిని విప్పుటకు మరియు ప్రదర్శించడానికి ఎలా సరైనదో మీరు చూడవచ్చు.


You can see that the message whose structure is shown here is a quite typical modern e-mail.

ఇక్కడ చూపబడిన నిర్మాణం కలిగిన సందేశం చాలా సాధారణ ఆధునిక ఇ-మెయిల్ అని మీరు చూడవచ్చు.


It also contains a file attachment, complete with a suggested file name in case the user wants to download it to the local filesystem.

ఇది వినియోగదారుడు స్థానిక ఫైల్ సిస్టమ్‌కు డౌన్‌లోడ్ చేయాలనుకుంటే, సూచించిన ఫైల్ పేరుతో సహా ఫైల్ అటాచ్‌మెంట్‌ను కూడా కలిగి ఉంది.


Our sample program does not attempt to save anything to the hard drive, both for simplicity and safety.

సరళత మరియు భద్రత కోసం, మా నమూనా ప్రోగ్రామ్ హార్డ్ డ్రైవ్‌లో దేనినీ సేవ్ చేయడానికి ప్రయత్నించదు.


If you examine the program listing, you will see that all of this is supported simply by calls to the IMAP fetch() method.

మీరు ప్రోగ్రామ్ జాబితాను పరిశీలిస్తే, ఇదంతా IMAP fetch() పద్ధతికి కాల్స్ ద్వారా మాత్రమే మద్దతు ఇవ్వబడుతుందని మీరు చూస్తారు.


Part names like HEADER and 1.1 are simply more options for what you can specify when you call fetch(), and can be used right alongside other values like BODY.

HEADER మరియు 1.1 వంటి భాగాల పేర్లు మీరు fetch()ని పిలిచినప్పుడు మీరు పేర్కొనగలిగే మరిన్ని ఎంపికలు మరియు BODY వంటి ఇతర విలువల పక్కన ఉపయోగించవచ్చు.


One oddity you will note is that the IMAP protocol does not actually provide you with any of the multipart names that a particular message supports!

మీరు గమనించే ఒక విచిత్రం ఏమిటంటే, IMAP ప్రోటోకాల్ వాస్తవానికి ఒక నిర్దిష్ట సందేశం మద్దతు ఇచ్చే బహుళ భాగాల పేర్లలో దేనినీ మీకు అందించదు!


You can see that our display_structure() routine here uses a simple loop to accomplish this counting.

ఈ లెక్కింపును సాధించడానికి మా display_structure() దినచర్య ఇక్కడ ఒక సాధారణ లూప్‌ను ఉపయోగిస్తుందని మీరు చూడవచ్చు.


One final note about the fetch() command: it lets you not only pull just the parts of a message that you need at any given moment, but also truncate them in case they are quite long and you just want to provide an excerpt from the beginning to tantalize the user!

fetch() కమాండ్ గురించి చివరి గమనిక: ఇది మీకు ఏ క్షణంలోనైనా అవసరమైన సందేశంలోని భాగాలను మాత్రమే లాగడానికి మిమ్మల్ని అనుమతిస్తుంది, కానీ అవి చాలా పొడవుగా ఉంటే వాటిని కుదించడానికి కూడా మిమ్మల్ని అనుమతిస్తుంది మరియు మీరు వినియోగదారుని ఆకర్షించడానికి ప్రారంభం నుండి ఒక భాగాన్ని అందించాలనుకుంటే!


You might have noticed, while trying out Listing 15–7 or reading its example output just shown, that IMAP marks messages with attributes called “flags,” which typically take the form of a backslash- prefixed word, like 	extbackslash Seen for one of the messages just cited.

మీరు జాబితా 15–7ని ప్రయత్నిస్తున్నప్పుడు లేదా ఇప్పుడే చూపిన దాని ఉదాహరణ అవుట్‌పుట్‌ను చదువుతున్నప్పుడు, IMAP సందేశాలను “ఫ్లాగ్‌లు” అని పిలువబడే లక్షణాలతో గుర్తిస్తుందని మీరు గమనించి ఉండవచ్చు, ఇవి సాధారణంగా బ్యాక్‌స్లాష్-ముందున్న పదం రూపంలో ఉంటాయి, 	extbackslash Seen వంటివి.ఇప్పుడే ఉదహరించిన సందేశాలలో ఒకటి.


Several of these are standard, and are defined in RFC 3501 for use on all IMAP servers.

వీటిలో కొన్ని ప్రామాణికమైనవి మరియు అన్ని IMAP సర్వర్‌లలో ఉపయోగం కోసం RFC 3501లో నిర్వచించబడ్డాయి.


The IMAPClient library supports several methods for working with flags.

ఫ్లాగ్‌లతో పని చేయడానికి IMAPClient లైబ్రరీ అనేక పద్ధతులను సపోర్ట్ చేస్తుంది.


In case you want to completely change the set of flags for a particular message without figuring out the correct series of adds and removes, you can use set_flags() to unilaterally replace the whole list of message flags with a new one:

మీరు సరైన శ్రేణిని జోడించడం మరియు తీసివేయడం వంటివి తెలుసుకోకుండానే ఒక నిర్దిష్ట సందేశం కోసం ఫ్లాగ్‌ల సమితిని పూర్తిగా మార్చాలనుకుంటే, మీరు సందేశ ఫ్లాగ్‌ల మొత్తం జాబితాను కొత్తదానితో ఏకపక్షంగా భర్తీ చేయడానికి set_flags()ని ఉపయోగించవచ్చు:


But, in general, Unix has no special characters, and this is a very important fact for you to grasp.

కానీ, సాధారణంగా, యూనిక్స్ ప్రత్యేక అక్షరాలను కలిగి ఉండదు మరియు మీరు అర్థం చేసుకోవలసిన చాలా ముఖ్యమైన విషయం ఇది.


If you have used a shell like bash for any great length of time at all, you may have come to view your system as a sort of very powerful and convenient minefield.

మీరు బాష్ వంటి షెల్‌ను ఎక్కువ కాలం ఉపయోగించినట్లయితే, మీరు మీ సిస్టమ్‌ను చాలా శక్తివంతమైన మరియు అనుకూలమైన మైన్‌ఫీల్డ్‌గా చూడవచ్చు.


On the one hand, it makes it very easy to, say, name all of the files in the current directory as arguments to a command; but on the other hand, it can be very difficult to echo a message to the screen that mixes single quotes and double-quotes.

ఒక వైపు, ప్రస్తుత డైరెక్టరీలోని అన్ని ఫైల్‌లను కమాండ్‌కు వాదనలుగా పేరు పెట్టడం చాలా సులభం చేస్తుంది; కానీ మరోవైపు, సింగిల్ కోట్స్ మరియు డబుల్ కోట్స్‌ను మిళితం చేసే సందేశాన్ని స్క్రీన్‌కు ఎకో చేయడం చాలా కష్టం.


The simple lesson of this section is that the whole set of conventions to which you are accustomed has nothing to do with your operating system; they are simply and entirely a behavior of the bash shell, or of whichever of the other popular (or arcane) shells that you are using.

ఈ విభాగం యొక్క సాధారణ పాఠం ఏమిటంటే, మీరు అలవాటు పడిన మొత్తం సమావేశాలకు మీ ఆపరేటింగ్ సిస్టమ్‌తో సంబంధం లేదు; అవి బాష్ షెల్ యొక్క ప్రవర్తన లేదా మీరు ఉపయోగిస్తున్న ఇతర ప్రసిద్ధ (లేదా రహస్య) షెల్‌లలో ఏదైనా.


It does not matter how familiar the rules seem, or how difficult it is for you to imagine using a Unix-like system without them.

నిబంధనలు ఎంత సుపరిచితంగా ఉన్నాయో లేదా వాటి లేకుండా యూనిక్స్ లాంటి వ్యవస్థను ఉపయోగించడం మీకు ఎంత కష్టమో అది ముఖ్యం కాదు.


If you take bash away, they are simply not there.

మీరు బాష్‌ను తీసివేస్తే, అవి అక్కడ ఉండవు.


You can observe this quite simply by taking control of the operating system's process launcher yourself and trying to throw some special characters at a familiar command.

మీరు ఆపరేటింగ్ సిస్టమ్ యొక్క ప్రాసెస్ లాంచర్‌ను మీరే నియంత్రించడం ద్వారా మరియు కొన్ని ప్రత్యేక అక్షరాలను తెలిసిన కమాండ్‌కు విసిరేయడానికి ప్రయత్నించడం ద్వారా దీన్ని చాలా సులభంగా గమనించవచ్చు.


Here, we are bypassing all of the shell applications that are available for interpreting commands, and we are telling the operating system to start a new process using precisely the list of arguments we have provided.

ఇక్కడ, మేము కమాండ్లను అర్థం చేసుకోవడానికి అందుబాటులో ఉన్న అన్ని షెల్ అప్లికేషన్‌లను దాటవేస్తున్నాము మరియు మేము అందించిన వాదనల జాబితాను ఖచ్చితంగా ఉపయోగించి కొత్త ప్రాసెస్‌ను ప్రారంభించమని ఆపరేటింగ్ సిస్టమ్‌కు చెబుతున్నాము.


And the process—the echo command, in this case—is getting exactly those characters, instead of having the * turned into a list of file names first.

మరియు ప్రక్రియ - ఈ సందర్భంలో ఎకో కమాండ్ - మొదట *ని ఫైల్ పేర్ల జాబితాగా మార్చడానికి బదులుగా, ఖచ్చితంగా ఆ అక్షరాలను పొందుతోంది.


Though we rarely think about it, the most common “special” character is one we use all the time: the space character!

మనం దాని గురించి చాలా అరుదుగా ఆలోచిస్తున్నప్పటికీ, అత్యంత సాధారణమైన “ప్రత్యేక” అక్షరం మనం ఎల్లప్పుడూ ఉపయోగించేది: స్పేస్ అక్షరం!


Rather than assume that you actually mean each space character to be passed to the command you are invoking, the shell instead interprets it as the delimiter separating the actual text you want the command to see.

మీరు వాస్తవానికి మీరు పిలుస్తున్న కమాండ్‌కు ప్రతి స్పేస్ అక్షరాన్ని పంపాలని అనుకుంటున్నారు అని అనుకోవడానికి బదులుగా, షెల్ బదులుగా మీరు కమాండ్ చూడాలనుకుంటున్న అసలు వచనాన్ని వేరుచేసే డీలిమిటర్‌గా అర్థం చేసుకుంటుంది.


This causes endless entertainment when people include spaces in Unix file names, and then try to move the file somewhere else.

యూనిక్స్ ఫైల్ పేర్లలో ప్రజలు స్పేస్‌లను చేర్చినప్పుడు మరియు ఫైల్‌ను మరెక్కడికైనా తరలించడానికి ప్రయత్నించినప్పుడు ఇది అంతులేని వినోదాన్ని కలిగిస్తుంది.


To make the shell understand that you are talking about one file with a space in its name, not two files, you have to contrive something like one of these possible command lines:

మీరు దాని పేరులో స్పేస్ ఉన్న ఒక ఫైల్ గురించి మాట్లాడుతున్నారని షెల్ అర్థం చేసుకోవడానికి, రెండు ఫైల్‌లు కాదు, మీరు ఈ కమాండ్ లైన్‌లలో ఒకదానిలా ఏదైనా కల్పించాలి:


That last possibility obviously means something quite different—since it will match any file name that happens to start with Smith and end with Contract.txt, regardless of whether the text between them is a simple space character or some much longer sequence of text—but I have seen many people type it in frustration who are still learning shell conventions and cannot remember how to type a literal space character for the shell.

చివరి అవకాశం స్పష్టంగా చాలా భిన్నమైన అర్థాన్నిస్తుంది - ఇది స్మిత్‌తో ప్రారంభమయ్యే మరియు కాంట్రాక్ట్.టెక్స్ట్ తో ముగిసే ఏదైనా ఫైల్ పేరుతో సరిపోలుతుంది, వాటి మధ్య వచనం సాధారణ స్పేస్ అక్షరం లేదా చాలా పొడవైన వచన క్రమం అయినా - కానీ షెల్ సమావేశాలను నేర్చుకుంటున్న మరియు షెల్ కోసం అక్షర స్పేస్ అక్షరాన్ని ఎలా టైప్ చేయాలో గుర్తుంచుకోలేని చాలా మంది ప్రజలు నిరాశతో టైప్ చేయడం నేను చూశాను.


If you want to convince yourself that none of the characters that the bash shell has taught you to be careful about is special, Listing 16–2 shows a simple shell, written in Python, that treats only the space as special but passes everything else through literally to the command.

బాష్ షెల్ మిమ్మల్ని జాగ్రత్తగా ఉండమని నేర్పించిన అక్షరాలలో ఏదీ ప్రత్యేకమైనది కాదని మీరు మిమ్మల్ని మీరు ఒప్పించాలనుకుంటే, జాబితా 16–2 ఒక సాధారణ షెల్‌ను చూపుతుంది, ఇది పైథాన్‌లో వ్రాయబడింది, ఇది స్పేస్‌ను మాత్రమే ప్రత్యేకంగా పరిగణిస్తుంది, కానీ మిగిలిన వాటిని అక్షరాలా కమాండ్‌కు పంపుతుంది.


Of course, this means that you cannot use this shell to talk about files with spaces in their names, since without at least one other special character—an escape or quoting character—you cannot make the spaces mean anything but the argument separator!

వాస్తవానికి, దీని అర్థం ఏమిటంటే, మీరు ఈ షెల్‌ను వారి పేర్లలో స్పేస్‌లతో ఉన్న ఫైల్‌ల గురించి మాట్లాడటానికి ఉపయోగించలేరు, ఎందుకంటే కనీసం మరొక ప్రత్యేక అక్షరం లేకుండా - ఎస్కేప్ లేదా కోటింగ్ అక్షరం - మీరు స్పేస్‌లను వాదన విభజనకర్త తప్ప మరేమీ అర్థం చేసుకోలేరు!


But you can quickly bring up this shell to try out all sorts of special characters of which you have always been afraid, and see that they mean absolutely nothing if passed directly to the common commands you use (the shell in Listing 16–2 uses a ] prompt, to make it easy to tell apart from your own shell):

కానీ మీరు ఎల్లప్పుడూ భయపడే అన్ని రకాల ప్రత్యేక అక్షరాలను ప్రయత్నించడానికి మీరు ఈ షెల్‌ను త్వరగా తీసుకురావచ్చు మరియు మీరు ఉపయోగించే సాధారణ కమాండ్‌లకు నేరుగా పంపితే అవి ఏమీ అర్థం కాదని చూడవచ్చు (జాబితా 16–2లోని షెల్ ] ప్రాంప్ట్‌ను ఉపయోగిస్తుంది, ఇది మీ స్వంత షెల్ నుండి వేరు చేయడం సులభం చేస్తుంది):


You can see here absolute evidence that Unix commands—in this case, the /bin/echo command that we are calling over and over again—do not generally attempt to interpret their arguments as anything other than strings.

యూనిక్స్ కమాండ్‌లు - ఈ సందర్భంలో, మనం పదేపదే పిలుస్తున్న /bin/echo కమాండ్ - సాధారణంగా వాటి వాదనలను స్ట్రింగ్‌లుగా కాకుండా మరేదైనా అర్థం చేసుకోవడానికి ప్రయత్నించవని మీరు ఇక్కడ ఖచ్చితమైన రుజువును చూడవచ్చు.


The echo command happily accepts double-quotes, dollar signs, and asterisks, and treats them all as literal characters.

ఎకో కమాండ్ సంతోషంగా డబుల్ కోట్స్, డాలర్ గుర్తులు మరియు నక్షత్రాలను అంగీకరిస్తుంది మరియు వాటిని అక్షర అక్షరాలుగా పరిగణిస్తుంది.


As the foregoing show command illustrates, Python is simply reducing our arguments to a list of strings for the operating system to use in creating a new process.

ముందుగా చూపిన కమాండ్ వివరించినట్లుగా, పైథాన్ కేవలం కొత్త ప్రాసెస్‌ను సృష్టించడంలో ఉపయోగించడానికి మా వాదనలను స్ట్రింగ్‌ల జాబితాకు తగ్గిస్తుంది.


You simply provide them in your call to the connect() method.

మీరు వాటిని కనెక్ట్() పద్ధతికి కాల్ చేసినప్పుడు అందిస్తారు.


Public-key authentication makes the Python code even easier!

పబ్లిక్-కీ ప్రమాణీకరణ పైథాన్ కోడ్‌ను మరింత సులభతరం చేస్తుంది!


If your identity key file is stored somewhere other than in the normal ~/.ssh/id_rsa file, then you can provide its file name.

మీ గుర్తింపు కీ ఫైల్ సాధారణ ~/.ssh/id_rsa ఫైల్ కాకుండా మరెక్కడైనా నిల్వ చేయబడితే, మీరు దాని ఫైల్ పేరును అందించవచ్చు.


Of course, per the normal rules of SSH, providing a public-key identity like this will work only if you have appended the public key in the id_sysadmin.pub file to your “authorized hosts” file.

వాస్తవానికి, SSH యొక్క సాధారణ నియమాల ప్రకారం, ఇలాంటి పబ్లిక్-కీ గుర్తింపును అందించడం, మీరు id_sysadmin.pub ఫైల్‌లోని పబ్లిక్ కీని మీ “అధికారిక హోస్ట్‌లు” ఫైల్‌కు జోడిస్తేనే పని చేస్తుంది.


If you have trouble getting public-key authentication to work, always check the file permissions.

పబ్లిక్-కీ ప్రమాణీకరణ పని చేయడంలో మీకు సమస్య ఉంటే, ఎల్లప్పుడూ ఫైల్ అనుమతులను తనిఖీ చేయండి.


The task of copying SSH keys to other accounts has actually been automated in recent versions.

SSH కీలను ఇతర ఖాతాలకు కాపీ చేసే పని వాస్తవానికి ఇటీవలి వెర్షన్‌లలో స్వయంచాలకంగా చేయబడింది.


Once the connect() method has succeeded, you are now ready to start performing remote operations.

కనెక్ట్() పద్ధతి విజయవంతమైన తర్వాత, మీరు ఇప్పుడు రిమోట్ కార్యకలాపాలను ప్రారంభించడానికి సిద్ధంగా ఉన్నారు.


Simply by asking, you can access remote-shell sessions, run individual commands, commence file-transfer sessions, and set up port forwarding.

అడగడం ద్వారా, మీరు రిమోట్-షెల్ సెషన్‌లను యాక్సెస్ చేయవచ్చు, వ్యక్తిగత ఆదేశాలను అమలు చేయవచ్చు, ఫైల్-ట్రాన్స్‌ఫర్ సెషన్‌లను ప్రారంభించవచ్చు మరియు పోర్ట్ ఫార్వార్డింగ్‌ను సెటప్ చేయవచ్చు.


First, SSH can set up a raw shell session for you.

ముందుగా, SSH మీ కోసం ఒక ముడి షెల్ సెషన్‌ను ఏర్పాటు చేయగలదు.


This kind of connection behaves very much like a Telnet connection.

ఈ రకమైన కనెక్షన్ టెల్నెట్ కనెక్షన్ లాగానే ప్రవర్తిస్తుంది.


A much better option for running remote commands is to use exec_command().

రిమోట్ ఆదేశాలను అమలు చేయడానికి చాలా మంచి ఎంపిక exec_command()ని ఉపయోగించడం.


The difference between exec_command() and a local subprocess is that you do not get the chance to pass command-line arguments as separate strings.

exec_command() మరియు స్థానిక ఉప ప్రక్రియ మధ్య వ్యత్యాసం ఏమిటంటే, మీరు కమాండ్-లైన్ వాదనలను ప్రత్యేక స్ట్రింగ్‌లుగా పాస్ చేయడానికి అవకాశం పొందలేరు.


Every time you start a new SSH shell session with invoke_shell(), and every time you kick off a command with exec_command(), a new SSH “channel” is created behind the scenes.

మీరు invoke_shell()తో కొత్త SSH షెల్ సెషన్‌ను ప్రారంభించిన ప్రతిసారీ మరియు మీరు exec_command()తో ఒక ఆదేశాన్ని ప్రారంభించిన ప్రతిసారీ, తెర వెనుక ఒక కొత్త SSH “ఛానెల్” సృష్టించబడుతుంది.


Channels, as just explained, can run in parallel, and SSH will cleverly interleave their data on your single SSH connection.

ఛానెల్‌లు, ఇప్పుడే వివరించినట్లుగా, సమాంతరంగా అమలు చేయబడతాయి మరియు SSH మీ సింగిల్ SSH కనెక్షన్‌లో వాటి డేటాను తెలివిగా మిళితం చేస్తుంది.


SFTP: SSH ద్వారా ఫైల్ బదిలీ


The SFTP protocol is an incredible boon.

SFTP ప్రోటోకాల్ ఒక అద్భుతమైన వరం.


The SFTP protocol is stateful, just like FTP.

SFTP ప్రోటోకాల్ FTP లాగానే స్టేట్‌ఫుల్.


You can open a file using either the file() or open() method.

మీరు file() లేదా open() పద్ధతిని ఉపయోగించి ఒక ఫైల్‌ను తెరవవచ్చు.


Be careful that you recognize this, or you might open so many channels at once that each one slows to a crawl.

దీన్ని మీరు గుర్తించాలని జాగ్రత్త వహించండి, లేకపోతే మీరు ఒకేసారి చాలా ఛానెల్‌లను తెరవవచ్చు, తద్వారా ప్రతి ఒక్కటి నెమ్మదిగా కదలడం ప్రారంభిస్తాయి.


If you try using a file name like * or one that has spaces or special characters, they are simply interpreted as part of the file name.

మీరు * వంటి ఫైల్ పేరును లేదా ఖాళీలు లేదా ప్రత్యేక అక్షరాలు ఉన్నదాన్ని ఉపయోగించడానికి ప్రయత్నిస్తే, అవి ఫైల్ పేరులో భాగంగానే అర్థం చేసుకోబడతాయి.


A much better alternative today is for service providers to support SFTP instead.

సేవా ప్రదాతలు SFTPకి మద్దతు ఇవ్వడం ఈ రోజుల్లో చాలా మంచి ప్రత్యామ్నాయం.


The FTP standard is RFC959, available at http://www.faqs.org/rfcs/rfc959.html.

FTP ప్రమాణం RFC959, ఇది http://www.faqs.org/rfcs/rfc959.html వద్ద అందుబాటులో ఉంది.


One connection is the control channel, which carries commands and the resulting acknowledgments or error codes.

ఒక కనెక్షన్ నియంత్రణ ఛానెల్, ఇది ఆదేశాలను మరియు ఫలితంగా వచ్చే అంగీకారాలు లేదా లోపం కోడ్‌లను కలిగి ఉంటుంది.


The second connection is the data channel, which is used solely for transmitting file data.

రెండవ కనెక్షన్ డేటా ఛానెల్, ఇది ఫైల్ డేటాను ప్రసారం చేయడానికి మాత్రమే ఉపయోగించబడుతుంది.


However, in actual practice, this capability is rarely used.

అయితే, వాస్తవానికి, ఈ సామర్థ్యం చాలా అరుదుగా ఉపయోగించబడుతుంది.


First, the FTP client establishes a command connection by connecting to the FTP port on the server.

ముందుగా, FTP క్లయింట్ సర్వర్ లోని FTP పోర్ట్‌కు కనెక్ట్ చేయడం ద్వారా కమాండ్ కనెక్షన్‌ను ఏర్పాటు చేస్తుంది.


The client authenticates itself, usually with username and password.

క్లయింట్ సాధారణంగా వినియోగదారు పేరు మరియు పాస్‌వర్డ్‌తో తనను తాను ప్రమాణీకరిస్తుంది.


The client changes directory on the server to where it wants to deposit or retrieve files.

ఫైల్‌లను డిపాజిట్ చేయడానికి లేదా తిరిగి పొందడానికి క్లయింట్ సర్వర్ లోని డైరెక్టరీని మారుస్తుంది.


The client begins listening on a new port for the data connection, and then informs the server about that port.

డేటా కనెక్షన్ కోసం క్లయింట్ కొత్త పోర్ట్‌ను వినడం ప్రారంభిస్తుంది, ఆపై ఆ పోర్ట్ గురించి సర్వర్‌కు తెలియజేస్తుంది.


The server connects to the port the client requested.

క్లయింట్ అభ్యర్థించిన పోర్ట్‌కు సర్వర్ కనెక్ట్ అవుతుంది.


This worked well in the early days of the Internet; back then, most every machine that could run FTP had a public IP address.

ఇంటర్నెట్ ప్రారంభ రోజుల్లో ఇది బాగా పనిచేసింది; అప్పట్లో, FTPని అమలు చేయగల దాదాపు ప్రతి యంత్రానికి పబ్లిక్ IP చిరునామా ఉండేది.


Firewalls blocking incoming connections to desktop and laptop machines are now quite common.

డెస్క్‌టాప్ మరియు ల్యాప్‌టాప్ యంత్రాలకు వచ్చే కనెక్షన్‌లను నిరోధించే ఫైర్‌వాల్‌లు ఇప్పుడు చాలా సాధారణం.


To accommodate this situation, FTP also supports what is known as passive mode.

ఈ పరిస్థితిని పరిష్కరించడానికి, FTP నిష్క్రియ మోడ్‌గా పిలువబడే వాటికి కూడా మద్దతు ఇస్తుంది.


Passive mode is today the default with most FTP clients, as well as Python’s ftplib module.

నిష్క్రియ మోడ్ ఈ రోజు చాలా FTP క్లయింట్‌లతో పాటు పైథాన్ యొక్క ftplib మాడ్యూల్‌తో డిఫాల్ట్‌గా ఉంది.


The Python module ftplib is the primary interface to FTP for Python programmers.

పైథాన్ ప్రోగ్రామర్‌ల కోసం FTPకి ftplib మాడ్యూల్ ప్రధాన ఇంటర్‌ఫేస్.


It handles the details of establishing the various connections for you, and provides convenient ways to automate common commands.

ఇది మీ కోసం వివిధ కనెక్షన్‌లను ఏర్పాటు చేసే వివరాలను నిర్వహిస్తుంది మరియు సాధారణ ఆదేశాలను స్వయంచాలకంగా చేయడానికి అనుకూలమైన మార్గాలను అందిస్తుంది.


If you are interested only in downloading files, the urllib2 module introduced in Chapter 1 supports FTP.

మీరు ఫైల్‌లను డౌన్‌లోడ్ చేయడంలో మాత్రమే ఆసక్తి కలిగి ఉంటే, అధ్యాయం 1లో ప్రవేశపెట్టిన urllib2 మాడ్యూల్ FTPకి మద్దతు ఇస్తుంది.


Listing 17–1 shows a very basic ftplib example.

జాబితా 17–1 చాలా ప్రాథమిక ftplib ఉదాహరణను చూపుతుంది.


The welcome message will generally have no information that could be usefully parsed by your program.

స్వాగత సందేశంలో సాధారణంగా మీ ప్రోగ్రామ్ ద్వారా ఉపయోగకరంగా విశ్లేషించగల సమాచారం ఉండదు.


The login() function can take several parameters, including a username, password, and a third, rarely used authentication token that FTP calls an “account.”

లాగిన్() ఫంక్షన్ వినియోగదారు పేరు, పాస్‌వర్డ్ మరియు FTP “ఖాతా” అని పిలిచే మూడవ, అరుదుగా ఉపయోగించే ప్రమాణీకరణ టోకెన్తో సహా అనేక పారామితులను తీసుకోవచ్చు.


The retrlines() function is used to download a file in ASCII mode.

retrlines() ఫంక్షన్ ASCII మోడ్‌లో ఫైల్‌ను డౌన్‌లోడ్ చేయడానికి ఉపయోగించబడుతుంది.


You can also upload files to a remote server.

మీరు రిమోట్ సర్వర్‌కు ఫైల్‌లను కూడా అప్‌లోడ్ చేయవచ్చు.


The storlines() function uploads a file in ASCII mode.

storlines() ఫంక్షన్ ASCII మోడ్‌లో ఫైల్‌ను అప్‌లోడ్ చేస్తుంది.


The ntransfercmd() function can be used for binary uploads and downloads.

ntransfercmd() ఫంక్షన్ బైనరీ అప్‌లోడ్‌లు మరియు డౌన్‌లోడ్‌ల కోసం ఉపయోగించవచ్చు.


It gives you more control over the transfer process and is often used to support a progress bar for the user.

ఇది బదిలీ ప్రక్రియపై మీకు ఎక్కువ నియంత్రణను ఇస్తుంది మరియు సాధారణంగా వినియోగదారు కోసం ప్రోగ్రెస్ బార్‌ను అందించడానికి ఉపయోగిస్తారు.


The ftplib module raises exceptions on errors.

ftplib మాడ్యూల్ లోపాలు సంభవించినప్పుడు మినహాయింపులను పెంచుతుంది.


You can use cwd() to change to a particular directory on the remote end.

మీరు రిమోట్ ఎండ్‌లో నిర్దిష్ట డైరెక్టరీకి మారడానికి cwd()ని ఉపయోగించవచ్చు.


The nlst() command returns a simple list of all entries in a given directory.

nlst() కమాండ్ ఇచ్చిన డైరెక్టరీలోని అన్ని ఎంట్రీల యొక్క సాధారణ జాబితాను అందిస్తుంది.


The dir() command returns a more detailed list but in server-specific format.

dir() కమాండ్ మరింత వివరణాత్మక జాబితాను అందిస్తుంది, కానీ సర్వర్-నిర్దిష్ట ఆకృతిలో.


Even with only nlst(), you can usually detect whether an entry is a file or directory.

nlst()తో కూడా, ఒక ఎంట్రీ ఫైల్ లేదా డైరెక్టరీనా అని మీరు సాధారణంగా గుర్తించవచ్చు.


After all, the choices we are talking about here — that you have to choose a data format, send a request, and receive a response in return — are not peculiar to procedure calls.

అన్నింటికంటే, ఇక్కడ మనం మాట్లాడుకుంటున్న ఎంపికలు — మీరు డేటా ఫార్మాట్‌ను ఎంచుకోవాలి, అభ్యర్థనను పంపాలి మరియు ప్రతిస్పందనను తిరిగి పొందాలి — విధాన కాల్‌లకు ప్రత్యేకమైనవి కావు.


First, an RPC protocol is distinguished by lacking strong semantics for the meaning of each call.

మొదట, RPC ప్రోటోకాల్ ప్రతి కాల్ యొక్క అర్థానికి బలమైన అర్థశాస్త్రం లేకపోవడం ద్వారా గుర్తించబడుతుంది.


Whereas HTTP is used to retrieve documents, and SMTP supports the delivery of messages, an RPC protocol does not assign any meaning to the data passed except to support basic data types like integers, floats, strings, and lists.

HTTP పత్రాలను తిరిగి పొందడానికి ఉపయోగించబడుతుంది మరియు SMTP సందేశాల డెలివరీకి మద్దతు ఇస్తుంది, అయితే RPC ప్రోటోకాల్ పూర్ణాంకాలు, ఫ్లోట్‌లు, స్ట్రింగ్‌లు మరియు జాబితాలు వంటి ప్రాథమిక డేటా రకాలను మద్దతు ఇవ్వడం తప్ప, పంపిన డేటాకు ఎటువంటి అర్థాన్ని కేటాయించదు.


It is instead up to each particular API that you fashion using an RPC protocol to define what its calls mean.

బదులుగా, దాని కాల్‌లు ఏమిటో నిర్వచించడానికి RPC ప్రోటోకాల్‌ను ఉపయోగించి మీరు రూపొందించే ప్రతి నిర్దిష్ట APIపై ఆధారపడి ఉంటుంది.


Second, RPC mechanisms are a way to invoke methods, but they do not define them.

రెండవది, RPC విధానాలు పద్ధతులను పిలిచే ఒక మార్గం, కానీ అవి వాటిని నిర్వచించవు.


When you read the specification of a more single-purpose protocol like HTTP or SMTP, you will note that they define a finite number of basic operations.

మీరు HTTP లేదా SMTP వంటి మరింత సింగిల్-పర్పస్ ప్రోటోకాల్ యొక్క స్పెసిఫికేషన్‌ను చదివినప్పుడు, అవి పరిమిత సంఖ్యలో ప్రాథమిక కార్యకలాపాలను నిర్వచిస్తాయని మీరు గమనించవచ్చు.


First, every RPC mechanism has limits on the kind of data you can pass.

మొదట, ప్రతి RPC విధానం మీరు పంపగల డేటా రకంపై పరిమితులను కలిగి ఉంటుంది.


The most general-purpose RPC mechanisms tend to be the most restrictive because they are designed to work with many different programming languages.

అత్యంత సాధారణ-ప్రయోజన RPC విధానాలు చాలా పరిమితంగా ఉంటాయి, ఎందుకంటే అవి అనేక విభిన్న ప్రోగ్రామింగ్ భాషలతో పని చేయడానికి రూపొందించబడ్డాయి.


Many Python programmers are disappointed to learn that only positional arguments are typically supported.

స్థానపరమైన వాదనలు మాత్రమే సాధారణంగా మద్దతు ఇవ్వబడతాయని తెలుసుకోవడానికి చాలా మంది పైథాన్ ప్రోగ్రామర్లు నిరాశ చెందుతారు.


A second common feature is the ability of the server to signal that an exception occurred while it was running the remote function.

రెండవ సాధారణ లక్షణం ఏమిటంటే, రిమోట్ ఫంక్షన్‌ను అమలు చేస్తున్నప్పుడు ఒక మినహాయింపు సంభవించిందని సర్వర్ సిగ్నల్ చేసే సామర్థ్యం.


The book provides a comprehensive guide to building network applications with Python.

ఈ పుస్తకం పైథాన్‌తో నెట్‌వర్క్ అప్లికేషన్‌లను రూపొందించడానికి ఒక సమగ్ర మార్గదర్శిని అందిస్తుంది.


UDP ఒక కనెక్షన్ లేని ప్రోటోకాల్.


The index provides a detailed listing of all the terms used in the book.

సూచిక పుస్తకంలో ఉపయోగించిన అన్ని పదాల యొక్క వివరణాత్మక జాబితాను అందిస్తుంది.


Email authentication is crucial for preventing spam.

స్పామ్‌ను నిరోధించడానికి ఇమెయిల్ ప్రమాణీకరణ చాలా ముఖ్యం.


The command-line interface offers powerful tools for automation.

కమాండ్-లైన్ ఇంటర్‌ఫేస్ ఆటోమేషన్ కోసం శక్తివంతమైన సాధనాలను అందిస్తుంది.


Understanding DNS is essential for network programming.

నెట్‌వర్క్ ప్రోగ్రామింగ్ కోసం DNSని అర్థం చేసుకోవడం చాలా అవసరం.


HTTP is the foundation of the World Wide Web.

HTTP వరల్డ్ వైడ్ వెబ్ యొక్క ఆధారం.


Cookies are used to store user session information.

వినియోగదారు సెషన్ సమాచారాన్ని నిల్వ చేయడానికి కుకీలను ఉపయోగిస్తారు.


The book covers various aspects of web server frameworks.

ఈ పుస్తకం వెబ్ సర్వర్ ఫ్రేమ్‌వర్క్‌ల యొక్క వివిధ అంశాలను వివరిస్తుంది.


File transfer protocol (FTP) is used for transferring files.

ఫైల్‌లను బదిలీ చేయడానికి ఫైల్ ట్రాన్స్‌ఫర్ ప్రోటోకాల్ (FTP) ఉపయోగించబడుతుంది.


The author explains the concepts of concurrent programming.

రచయిత ఏకకాలిక ప్రోగ్రామింగ్ భావనలను వివరిస్తాడు.


The book delves into the details of email protocols like SMTP and IMAP.

ఈ పుస్తకం SMTP మరియు IMAP వంటి ఇమెయిల్ ప్రోటోకాల్‌ల వివరాలను వివరిస్తుంది.


The use of HTTPS ensures secure communication.

HTTPSని ఉపయోగించడం సురక్షితమైన కమ్యూనికేషన్‌ను నిర్ధారిస్తుంది.


The book provides examples of screen scraping techniques.

ఈ పుస్తకం స్క్రీన్ స్క్రాపింగ్ పద్ధతుల ఉదాహరణలను అందిస్తుంది.


The book discusses the importance of data abstraction.

డేటా అబ్‌స్ట్రాక్షన్ యొక్క ప్రాముఖ్యతను ఈ పుస్తకం చర్చిస్తుంది.


The book explains the concept of event-driven servers.

ఈ పుస్తకం ఈవెంట్-డ్రివెన్ సర్వర్ల భావనను వివరిస్తుంది.


The book covers the basics of command-line editing.

ఈ పుస్తకం కమాండ్-లైన్ ఎడిటింగ్ యొక్క ప్రాథమిక అంశాలను వివరిస్తుంది.


The book explores the use of threading in Python.

ఈ పుస్తకం పైథాన్‌లో థ్రెడింగ్‌ను ఎలా ఉపయోగించాలో వివరిస్తుంది.


The book provides information on the use of caching.

ఈ పుస్తకం కాషింగ్ వాడకం గురించి సమాచారాన్ని అందిస్తుంది.


The book discusses the use of XML-RPC for remote procedure calls.

రిమోట్ విధాన కాల్‌ల కోసం XML-RPCని ఎలా ఉపయోగించాలో ఈ పుస్తకం చర్చిస్తుంది.


If you need to transmit this dictionary over an RPC mechanism, your first instinct might be to change the numbers to strings.

మీరు ఈ నిఘంటువును RPC విధానం ద్వారా ప్రసారం చేయవలసి వస్తే, మీ మొదటి ఆలోచన సంఖ్యలను స్ట్రింగ్‌లుగా మార్చడం కావచ్చు.


Simply put, the struct and object RPC data structures are not designed to pair keys with values in containers of an arbitrary size.

సులభంగా చెప్పాలంటే, struct మరియు object RPC డేటా నిర్మాణాలు కీలను యాదృచ్ఛిక పరిమాణంలోని కంటైనర్‌లలోని విలువలతో జత చేయడానికి రూపొందించబడలేదు.


Instead, they are designed to associate a small set of pre-defined attribute names with the attribute values that they happen to carry for some particular object.

బదులుగా, అవి కొన్ని నిర్దిష్ట వస్తువు కోసం తీసుకువెళ్ళే లక్షణ విలువలతో ప్రీ-డిఫైన్ చేయబడిన లక్షణాల పేర్ల చిన్న సమితిని అనుబంధించడానికి రూపొందించబడ్డాయి.


If you try to use a struct to pair random keys and values, you might inadvertently make it very difficult to use for people unfortunate enough to be using statically-typed programming languages.

మీరు యాదృచ్ఛిక కీలు మరియు విలువలను జత చేయడానికి structని ఉపయోగించడానికి ప్రయత్నిస్తే, స్టాటిక్‌గా టైప్ చేయబడిన ప్రోగ్రామింగ్ భాషలను ఉపయోగిస్తున్న దురదృష్టవంతులైన వ్యక్తులకు దీన్ని ఉపయోగించడం చాలా కష్టతరం చేయవచ్చు.


Instead, you should think of dictionaries being sent across RPCs as being like the __dict__ attributes of your Python objects.

బదులుగా, RPCల ద్వారా పంపబడుతున్న నిఘంటువులను మీ పైథాన్ వస్తువుల __dict__ లక్షణాల వలె పరిగణించాలి.


Just as your Python objects tend to have a small collection of attribute names that are well-known to your code, the dictionaries you send across RPC should associate a small number of pre-defined keys with their related values.

మీ పైథాన్ వస్తువులకు మీ కోడ్‌కు బాగా తెలిసిన లక్షణాల పేర్ల చిన్న సేకరణ ఉన్నట్లే, మీరు RPC ద్వారా పంపే నిఘంటువులు కొన్ని ముందుగా నిర్వచించిన కీలను వాటి సంబంధిత విలువలతో అనుబంధించాలి.


All of this means that the dictionary that I showed a few moments ago should actually be serialized as a list of explicitly labelled values if it is going to be used by a general-purpose RPC mechanism.

ఇదంతా అర్థం ఏమిటంటే, నేను కొద్ది క్షణాల క్రితం చూపించిన నిఘంటువును సాధారణ-ప్రయోజన RPC విధానం ద్వారా ఉపయోగించబోతున్నట్లయితే, స్పష్టంగా లేబుల్ చేయబడిన విలువల జాబితాగా సీరియలైజ్ చేయాలి.


The key difference in this approach (besides the fact that this dictionary is appallingly longer) is that the earlier data structure was meaningless unless you knew ahead of time what the keys and values meant.

ఈ విధానంలో ముఖ్యమైన వ్యత్యాసం (ఈ నిఘంటువు భయంకరంగా పొడవుగా ఉందనే వాస్తవం కాకుండా) ఏమిటంటే, మీరు ముందుగానే కీలు మరియు విలువలు ఏమిటో తెలియనంత వరకు మునుపటి డేటా నిర్మాణం అర్థరహితంగా ఉంది.


But here we are including names with the data and that makes this example self-descriptive to some extent; that is, someone looking at this data on the wire or in his program has a higher chance of guessing what it represents.

కానీ ఇక్కడ మేము డేటాతో పేర్లను చేర్చుతున్నాము మరియు ఇది ఈ ఉదాహరణను కొంతవరకు స్వీయ-వివరణాత్మకంగా చేస్తుంది; అంటే, వైర్‌లో లేదా అతని ప్రోగ్రామ్‌లో ఈ డేటాను చూసే ఎవరైనా ఇది దేనిని సూచిస్తుందో ఊహించే అవకాశం ఉంది.


I will not argue that this is always a good idea.

ఇది ఎల్లప్పుడూ మంచి ఆలోచన అని నేను వాదించను.


If you have a Python dictionary like the one we are discussing here, you can turn it into an RPC- appropriate data structure, and then change it back with code like this:

మీరు ఇక్కడ చర్చిస్తున్న దానిలాంటి పైథాన్ నిఘంటువును కలిగి ఉంటే, మీరు దానిని RPC- తగిన డేటా స్ట్రక్చర్‌గా మార్చవచ్చు, ఆపై ఇలాంటి కోడ్‌తో తిరిగి మార్చవచ్చు:


వస్తువుల గురించి మాట్లాడుకోవడం: పైరో మరియు RPyC


If the idea of RPC was to make remote function calls look like local ones, then the two basic RPC mechanisms we have looked at actually fail pretty spectacularly.

RPC యొక్క ఆలోచన రిమోట్ ఫంక్షన్ కాల్‌లను స్థానిక కాల్‌లుగా కనిపించేలా చేయడానికి ఉద్దేశించబడితే, మనం చూసిన రెండు ప్రాథమిక RPC విధానాలు వాస్తవానికి చాలా అద్భుతంగా విఫలమవుతాయి.


What happens when you need to pass live objects?

మీరు లైవ్ ఆబ్జెక్ట్‌లను పాస్ చేయవలసి వస్తే ఏమి జరుగుతుంది?


This is generally a very hard problem to solve for two reasons.

ఇది సాధారణంగా రెండు కారణాల వల్ల పరిష్కరించడానికి చాలా కష్టమైన సమస్య.


First, objects have different behaviors and semantics in different programming languages.

ముందుగా, వివిధ ప్రోగ్రామింగ్ భాషలలో వస్తువులకు విభిన్న ప్రవర్తనలు మరియు అర్థశాస్త్రం ఉంటాయి.


Second, it is often not clear how much state needs to travel with an object to make it useful on another computer.

రెండవది, మరొక కంప్యూటర్‌లో ఉపయోగకరంగా ఉండటానికి ఒక వస్తువుతో ఎంత స్థితి ప్రయాణించాలో తరచుగా స్పష్టంగా ఉండదు.


However, both schemes often result in expensive and slow services, and they can make it very difficult to keep track of how one object is allowed to affect the answers provided by another service on the other end of the network.

అయితే, రెండు పథకాలు తరచుగా ఖరీదైన మరియు నెమ్మదిగా నడిచే ఫలితాలను ఇస్తాయి, మరియు ఒక వస్తువు నెట్‌వర్క్ యొక్క మరొక చివరన ఉన్న మరొక సర్వీస్ అందించిన సమాధానాలను ఎలా ప్రభావితం చేస్తుందో ట్రాక్ చేయడం చాలా కష్టతరం చేస్తాయి.


In fact, the task that XML-RPC and JSON-RPC forces upon you — the task of breaking down the question you want to ask a remote service so simple data types can be easily transmitted — often winds up being, simply, the task of software architecture.

వాస్తవానికి, XML-RPC మరియు JSON-RPC మీపై బలవంతంగా విధించే పని - మీరు రిమోట్ సర్వీస్‌ను అడగాలనుకుంటున్న ప్రశ్నను విచ్ఛిన్నం చేసే పని, తద్వారా సాధారణ డేటా రకాలను సులభంగా ప్రసారం చేయవచ్చు - తరచుగా, కేవలం, సాఫ్ట్‌వేర్ ఆర్కిటెక్చర్ యొక్క పనిగా ముగుస్తుంది.


Therefore, I recommend against jumping to a more object-based RPC service simply to avoid having to design your remote services and figure out exactly what data they need to do their job.

అందువల్ల, మీ రిమోట్ సర్వీస్‌లను రూపొందించకుండా మరియు వాటి పనిని చేయడానికి వారికి ఖచ్చితంగా ఏ డేటా అవసరమో తెలుసుకోవడానికి, మరింత వస్తువు-ఆధారిత RPC సేవకు వెళ్లవద్దని నేను సిఫార్సు చేస్తున్నాను.


The book provides a comprehensive guide to building network applications with Python.

పుస్తకం పైథాన్‌తో నెట్‌వర్క్ అప్లికేషన్‌లను రూపొందించడానికి ఒక సమగ్ర మార్గదర్శిని అందిస్తుంది.


Sockets are fundamental for network communication.

నెట్‌వర్క్ కమ్యూనికేషన్ కోసం సాకెట్‌లు చాలా ముఖ్యమైనవి.


TCP is a reliable protocol, ensuring data delivery.

TCP ఒక నమ్మదగిన ప్రోటోకాల్, ఇది డేటా డెలివరీని నిర్ధారిస్తుంది.


Understanding the basics of UDP is crucial for certain applications.

కొన్ని నిర్దిష్ట అనువర్తనాల కోసం UDP యొక్క ప్రాథమికాలను అర్థం చేసుకోవడం చాలా అవసరం.


The example uses the socket() function to create a socket.

ఉదాహరణ సాకెట్ను సృష్టించడానికి socket() ఫంక్షన్‌ను ఉపయోగిస్తుంది.


Error handling is essential when working with network programming.

నెట్‌వర్క్ ప్రోగ్రామింగ్‌తో పని చేస్తున్నప్పుడు ఎర్రర్ హ్యాండ్లింగ్ చాలా అవసరం.


The server listens for incoming connections on a specific port.

సర్వర్ ఒక నిర్దిష్ట పోర్ట్‌లో ఇన్‌కమింగ్ కనెక్షన్‌ల కోసం వింటుంది.


This code demonstrates a simple client-server interaction.

ఈ కోడ్ ఒక సాధారణ క్లయింట్-సర్వర్ పరస్పర చర్యను ప్రదర్శిస్తుంది.


The book covers topics like threading and multi-processing.

పుస్తకం థ్రెడింగ్ మరియు మల్టీ-ప్రాసెసింగ్ వంటి అంశాలను కవర్ చేస్తుంది.


Using SSL/TLS is important for secure communication.

సురక్షిత కమ్యూనికేషన్ కోసం SSL/TLSని ఉపయోగించడం చాలా ముఖ్యం.


The example shows how to send email using SMTP.

SMTPని ఉపయోగించి ఇమెయిల్ ఎలా పంపాలో ఉదాహరణ చూపిస్తుంది.


Web frameworks simplify web application development.

వెబ్ ఫ్రేమ్‌వర్క్‌లు వెబ్ అప్లికేషన్ అభివృద్ధిని సులభతరం చేస్తాయి.


Understanding HTTP requests and responses is crucial.

HTTP అభ్యర్థనలు మరియు ప్రతిస్పందనలను అర్థం చేసుకోవడం చాలా ముఖ్యం.


The book also discusses XML-RPC for remote procedure calls.

రిమోట్ విధాన కాల్‌ల కోసం XML-RPC గురించి కూడా పుస్తకం చర్చిస్తుంది.


Properly handling file descriptors is important for efficiency.

సమర్థత కోసం ఫైల్ డిస్క్రిప్టర్‌లను సరిగ్గా నిర్వహించడం చాలా ముఖ్యం.


The use of SSH for secure shell access is explained.

సురక్షిత షెల్ యాక్సెస్ కోసం SSH వినియోగం వివరించబడింది.


The book provides examples of using the telnetlib module.

టెల్నెట్‌లిబ్ మాడ్యూల్‌ను ఉపయోగించడం యొక్క ఉదాహరణలను పుస్తకం అందిస్తుంది.


The index provides a quick reference to various topics.

సూచిక వివిధ అంశాలకు శీఘ్ర సూచనను అందిస్తుంది.


The book is a valuable resource for network programmers.

పుస్తకం నెట్‌వర్క్ ప్రోగ్రామర్‌లకు విలువైన వనరు.


This comprehensive guide covers a wide range of network programming concepts.

ఈ సమగ్ర మార్గదర్శిని విస్తృత శ్రేణి నెట్‌వర్క్ ప్రోగ్రామింగ్ భావనలను కవర్ చేస్తుంది.