{"en":"The book provides a comprehensive guide to building network applications with Python.","translation":"పుస్తకం పైథాన్తో నెట్‌వర్క్ అప్లికేషన్‌లను రూపొందించడానికి ఒక సమగ్ర మార్గదర్శిని అందిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"This second edition includes updated information and examples.","translation":"ఈ రెండవ ఎడిషన్‌లో నవీకరించబడిన సమాచారం మరియు ఉదాహరణలు ఉన్నాయి.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"The book is copyrighted by Brandon Rhodes and John Goerzen.","translation":"ఈ పుస్తకానికి బ్రాండన్ రోడ్స్ మరియు జాన్ గోర్జన్ కాపీరైట్ కలిగి ఉన్నారు.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"No part of this work may be reproduced without permission.","translation":"ఈ పనిలో ఏ భాగాన్ని అనుమతి లేకుండా పునరుత్పత్తి చేయకూడదు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The ISBN numbers are provided for reference.","translation":"సూచన కోసం ISBN సంఖ్యలు అందించబడ్డాయి.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"The book was printed in the United States of America.","translation":"పుస్తకం అమెరికా సంయుక్త రాష్ట్రాల్లో ముద్రించబడింది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Trademarked names are used editorially.","translation":"ట్రేడ్‌మార్క్ పేర్లను సంపాదకీయంగా ఉపయోగిస్తారు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The publisher is Apress.","translation":"ప్రచురణకర్త అప్రెస్.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"The book's source code is available online.","translation":"పుస్తకం యొక్క సోర్స్ కోడ్ ఆన్‌లైన్‌లో అందుబాటులో ఉంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"The book covers topics like UDP sockets and TCP.","translation":"పుస్తకం UDP సాకెట్లు మరియు TCP వంటి అంశాలను కవర్ చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"It also discusses socket names and DNS.","translation":"ఇది సాకెట్ పేర్లు మరియు DNS గురించి కూడా చర్చిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Network data and network errors are also explained.","translation":"నెట్‌వర్క్ డేటా మరియు నెట్‌వర్క్ లోపాలను కూడా వివరిస్తారు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The book includes information on TLS and SSL.","translation":"పుస్తకంలో TLS మరియు SSL గురించిన సమాచారం ఉంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Server architecture and design are also discussed.","translation":"సర్వర్ ఆర్కిటెక్చర్ మరియు డిజైన్ గురించి కూడా చర్చించబడింది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The book covers caches, message queues, and map-reduce.","translation":"పుస్తకం కాష్‌లు, సందేశ క్యూలు మరియు మ్యాప్-రెడ్యూస్‌ను కవర్ చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"HTTP, screen scraping, and web applications are also included.","translation":"HTTP, స్క్రీన్ స్క్రాపింగ్ మరియు వెబ్ అప్లికేషన్‌లు కూడా చేర్చబడ్డాయి.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"E-mail composition and decoding are explained.","translation":"ఇ-మెయిల్ కూర్పు మరియు డీకోడింగ్ వివరించబడ్డాయి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The book also covers SMTP, POP, and IMAP.","translation":"పుస్తకం SMTP, POP మరియు IMAP లను కూడా కవర్ చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Telnet and SSH are also discussed in the book.","translation":"టెల్నెట్ మరియు SSH గురించి కూడా పుస్తకంలో చర్చించబడింది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The book concludes with FTP and RPC.","translation":"పుస్తకం FTP మరియు RPCతో ముగుస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Sockets provide the same idea for the networking realm.","translation":"నెట్‌వర్కింగ్ ప్రపంచానికి సాకెట్లు అదే ఆలోచనను అందిస్తాయి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"When you ask for access to a line of communication, you create one of these abstract “socket” objects.","translation":"మీరు కమ్యూనికేషన్ లైన్‌ను యాక్సెస్ చేయమని అడిగినప్పుడు, మీరు ఈ అమూర్త “సాకెట్” వస్తువులలో ఒకదాన్ని సృష్టిస్తారు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Sockets actually are file descriptors, which happen to be connected to network sources of data rather than to data stored on a filesystem.","translation":"వాస్తవానికి సాకెట్లు ఫైల్ డిస్క్రిప్టర్లు, ఇవి ఫైల్‌సిస్టమ్‌లో నిల్వ చేయబడిన డేటాకు కాకుండా నెట్‌వర్క్ డేటా మూలాలకు కనెక్ట్ చేయబడతాయి.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"This gives them some unusual abilities relative to normal files.","translation":"ఇది సాధారణ ఫైల్‌లతో పోలిస్తే వారికి కొన్ని అసాధారణ సామర్థ్యాలను ఇస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Take a look at Listing 2–1, which shows a simple server and client.","translation":"ఒక సాధారణ సర్వర్ మరియు క్లయింట్‌ను చూపే జాబితా 2–1ని చూడండి.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"You can see already that all sorts of operations are taking place that are drawn from the socket module in the Python Standard Library.","translation":"మీరు ఇప్పటికే పైథాన్ స్టాండర్డ్ లైబ్రరీలోని సాకెట్ మాడ్యూల్ నుండి తీసుకోబడిన అన్ని రకాల కార్యకలాపాలు జరుగుతున్నాయని చూడవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Try running the server first.","translation":"ముందుగా సర్వర్‌ను అమలు చేయడానికి ప్రయత్నించండి.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"It first created a plain socket with the socket() call.","translation":"ఇది మొదట సాకెట్() కాల్‌తో ఒక సాధారణ సాకెట్‌ను సృష్టించింది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"At this point, an exception could be raised if another program is already using that UDP port.","translation":"ఈ సమయంలో, మరొక ప్రోగ్రామ్ ఇప్పటికే ఆ UDP పోర్ట్‌ను ఉపయోగిస్తుంటే, ఒక మినహాయింపును పెంచవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"I glanced over the list and made the gamble that you, gentle reader, are not running SAP BusinessObjects Polestar.","translation":"నేను జాబితాను పరిశీలించాను మరియు మీరు, సున్నితమైన పాఠకుడిగా, SAP బిజినెస్ ఆబ్జెక్ట్స్ పోల్‌స్టార్‌ను అమలు చేయలేదని పందెం కాశాను.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Note that the Python program can always use a socket’s getsockname() method to retrieve the current IP and port.","translation":"ప్రస్తుత IP మరియు పోర్ట్‌ను తిరిగి పొందడానికి పైథాన్ ప్రోగ్రామ్ ఎల్లప్పుడూ సాకెట్ యొక్క getsockname() పద్ధతిని ఉపయోగించవచ్చని గమనించండి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Once the socker has been bound successfully, the server is ready to start receiving requests!","translation":"సాకెట్ విజయవంతంగా బంధించబడిన తర్వాత, సర్వర్ అభ్యర్థనలను స్వీకరించడానికి సిద్ధంగా ఉంది!","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"It enters a loop and repeatedly runs recvfrom().","translation":"ఇది ఒక లూప్‌లోకి ప్రవేశిస్తుంది మరియు పదేపదే recvfrom()ని అమలు చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"So let’s start up our client and see the result.","translation":"కాబట్టి మన క్లయింట్‌ను ప్రారంభిద్దాం మరియు ఫలితాన్ని చూద్దాం.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"The client code is also shown in Listing 2–1, beneath the test of sys.argv for the string 'client'.","translation":"క్లయింట్ కోడ్ జాబితా 2–1లో కూడా చూపబడింది, 'క్లయింట్' స్ట్రింగ్ కోసం sys.argv పరీక్ష క్రింద.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"This lets us see that both IP address and port number start as all zeroes.","translation":"IP చిరునామా మరియు పోర్ట్ నంబర్ రెండూ సున్నాలుగా ప్రారంభమవుతాయని ఇది మనకు చూడటానికి వీలు కల్పిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Then the client calls sendto() with both a message and a destination address.","translation":"అప్పుడు క్లయింట్ సందేశం మరియు గమ్యస్థాన చిరునామా రెండింటితో sendto()ని పిలుస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"So the operating system assigns one automatically.","translation":"కాబట్టి ఆపరేటింగ్ సిస్టమ్ ఒకదాన్ని స్వయంచాలకంగా కేటాయిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Since the client knows that he is expecting a reply from the server, he simply calls the socket’s recv() method.","translation":"క్లయింట్ సర్వర్ నుండి సమాధానం వస్తుందని తెలుసుకున్నందున, అతను కేవలం సాకెట్ యొక్క recv() పద్ధతిని పిలుస్తాడు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Each time the client runs, a complete round-trip of request and reply is passing between two UDP sockets.","translation":"క్లయింట్ ప్రతిసారీ నడుస్తున్నప్పుడు, అభ్యర్థన మరియు ప్రత్యుత్తరం యొక్క పూర్తి రౌండ్-ట్రిప్ రెండు UDP సాకెట్‌ల మధ్య వెళుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"The client will wait forever for a response.","translation":"క్లయింట్ ప్రతిస్పందన కోసం ఎప్పటికీ వేచి ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Try running the client from Listing 2–1 in one window.","translation":"ఒక విండోలో జాబితా 2–1 నుండి క్లయింట్‌ను అమలు చేయడానికి ప్రయత్నించండి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The client is now waiting—perhaps forever—for a response.","translation":"క్లయింట్ ఇప్పుడు వేచి ఉంది— బహుశా ఎప్పటికీ— ప్రతిస్పందన కోసం.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"But what if we nefariously try sending it back a packet from a different server, instead?","translation":"కానీ మనం మోసపూరితంగా వేరే సర్వర్ నుండి ప్యాకెట్‌ను తిరిగి పంపడానికి ప్రయత్నిస్తే ఏమిటి?","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Even though this Python session has grabbed a completely wild port number, which looks nothing like 1060 nor is even close, the client happily accepts this fake reply as an answer and prints it to the screen!","translation":"ఈ పైథాన్ సెషన్ పూర్తిగా అస్థిరమైన పోర్ట్ నంబర్‌ను పొందినప్పటికీ, ఇది 1060 లాగా లేదు లేదా దగ్గరగా కూడా లేదు, క్లయింట్ ఈ నకిలీ సమాధానాన్ని సంతోషంగా అంగీకరిస్తుంది మరియు దానిని తెరపై ముద్రిస్తుంది!","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Disaster!","translation":"విపత్తు!","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"It turns out that our first client accepts answers from anywhere.","translation":"మా మొదటి క్లయింట్ ఎక్కడి నుండైనా సమాధానాలను అంగీకరిస్తుందని తేలింది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"If a real UDP client were written this way, and an attacker or malcontent knew that we were running it, then they could send packets to its UDP port.","translation":"ఒకవేళ నిజమైన UDP క్లయింట్ ఈ విధంగా వ్రాయబడితే, మరియు ఒక దాడి చేసే వ్యక్తి లేదా అసంతృప్తి చెందిన వ్యక్తి మేము దానిని నడుపుతున్నామని తెలిస్తే, వారు దాని UDP పోర్ట్‌కు ప్యాకెట్‌లను పంపవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"This is because of the second, less-obvious effect of using connect() to select a UDP socket’s destination.","translation":"దీనికి కారణం connect()ని ఉపయోగించడం వల్ల కలిగే రెండవ, తక్కువ స్పష్టమైన ప్రభావం UDP సాకెట్ యొక్క గమ్యాన్ని ఎంచుకోవడం.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"You can use sendto() and direct each outgoing packet to a specific destination.","translation":"మీరు sendto()ని ఉపయోగించవచ్చు మరియు ప్రతి అవుట్‌గోయింగ్ ప్యాకెట్‌ను నిర్దిష్ట గమ్యస్థానానికి పంపవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"You can connect() your socket right after creating it.","translation":"మీరు సాకెట్‌ను సృష్టించిన వెంటనే connect() చేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"After you have connected a UDP socket using connect(), you can use the socket’s getpeername() method.","translation":"connect()ని ఉపయోగించి మీరు UDP సాకెట్‌ను కనెక్ట్ చేసిన తర్వాత, మీరు సాకెట్ యొక్క getpeername() పద్ధతిని ఉపయోగించవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Be careful about calling this on a socket that is not yet connected.","translation":"ఇంకా కనెక్ట్ చేయని సాకెట్‌లో దీన్ని కాల్ చేసేటప్పుడు జాగ్రత్త వహించండి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"First, doing a connect() on a UDP socket, of type SOCK_DGRAM, does not send any information across the network.","translation":"ముందుగా, SOCK_DGRAM రకం యొక్క UDP సాకెట్‌పై connect() చేయడం వలన నెట్‌వర్క్ ద్వారా ఎటువంటి సమాచారం పంపబడదు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Second, doing a connect(), or even filtering out unwanted packets yourself using the return address, is not a form of security!","translation":"రెండవది, కనెక్ట్ చేయడం లేదా రిటర్న్ చిరునామాను ఉపయోగించి మీరు కోరుకోని ప్యాకెట్‌లను ఫిల్టర్ చేయడం భద్రత కాదు!","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"If there is someone on the network who is really malicious, it is usually easy enough for their computer to forge packets with the server’s return address.","translation":"నెట్‌వర్క్‌లో నిజంగా హానికరమైన వ్యక్తి ఉంటే, వారి కంప్యూటర్ సర్వర్ యొక్క రిటర్న్ చిరునామాతో ప్యాకెట్‌లను ఫోర్జ్ చేయడం సాధారణంగా సులభం.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Sending packets with another computer’s return address is called spoofing.","translation":"మరొక కంప్యూటర్ యొక్క రిటర్న్ చిరునామాతో ప్యాకెట్‌లను పంపడాన్ని స్ఫూఫింగ్ అంటారు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The messages sent in both Listings 2–1 and 2–2 were simple text.","translation":"జాబితాలు 2–1 మరియు 2–2 రెండింటిలోనూ పంపిన సందేశాలు సాధారణ వచనం.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"But if you should ever design a scheme of your own for doing UDP requests and responses, you should strongly consider adding a sequence number to each request.","translation":"కానీ మీరు UDP అభ్యర్థనలు మరియు ప్రతిస్పందనలను చేయడానికి మీ స్వంత పథకాన్ని రూపొందించినట్లయితే, మీరు ప్రతి అభ్యర్థనకు సీక్వెన్స్ నంబర్‌ను జోడించడాన్ని తీవ్రంగా పరిగణించాలి.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Request IDs protect you against that.","translation":"అభ్యర్థన IDలు మిమ్మల్ని దాని నుండి రక్షిస్తాయి.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"We will now explore, in detail, how the sophisticated Google Maps service is actually just the top layer of a network stack.","translation":"ఇప్పుడు, అధునాతన Google Maps సేవ వాస్తవానికి నెట్‌వర్క్ స్టాక్ యొక్క టాప్ లేయర్ మాత్రమే అని వివరంగా చూద్దాం.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"What if we had to build a client for Google’s Maps API on our own?","translation":"మన స్వంతంగా Google యొక్క Maps API కోసం ఒక క్లయింట్‌ను నిర్మించాల్సి వస్తే ఏమిటి?","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Fetching a JSON Document from the Google Maps URL","translation":"Google Maps URL నుండి JSON డాక్యుమెంట్‌ను పొందడం","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Running this Python program returns an answer quite similar to that of our first script.","translation":"ఈ పైథాన్ ప్రోగ్రామ్‌ను అమలు చేయడం వలన మన మొదటి స్క్రిప్ట్‌కు సమానమైన సమాధానం వస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"In search2.py, we have stepped one rung down the ladder.","translation":"search2.py లో, మేము మెట్లపై ఒక మెట్టు దిగాము.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Unless you look very closely at this code, you might not even see that it’s asking about a mailing address at all!","translation":"మీరు ఈ కోడ్‌ను చాలా దగ్గరగా పరిశీలించకపోతే, ఇది మెయిలింగ్ చిరునామా గురించి అడుగుతుందని కూడా మీకు తెలియకపోవచ్చు!","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"If you want to read their documentation, by the way, you can find the Google Maps API described here.","translation":"మీరు వారి డాక్యుమెంటేషన్‌ను చదవాలనుకుంటే, మీరు Google Maps API ని ఇక్కడ చూడవచ్చు.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"The other parameters indicate the format in which we want the output returned.","translation":"ఇతర పారామితులు మనం అవుట్‌పుట్‌ను ఏ ఫార్మాట్‌లో తిరిగి పొందాలనుకుంటున్నామో సూచిస్తాయి.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"The search2.py script, then, does exactly the same thing as the first one.","translation":"అయితే, search2.py స్క్రిప్ట్ మొదటి దానితో సమానంగానే చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"This is a common difference when you step down a level from one layer of a network stack to the layer beneath it.","translation":"నెట్‌వర్క్ స్టాక్ యొక్క ఒక లేయర్ నుండి దాని క్రింది లేయర్‌కు ఒక స్థాయిని తగ్గించినప్పుడు ఇది ఒక సాధారణ వ్యత్యాసం.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"But the real reason that a URL can be used to fetch a document, of course, is that the URL is a kind of a recipe that describes where to find—and how to fetch—a given document on the web.","translation":"కానీ, వాస్తవానికి, URL ని డాక్యుమెంట్‌ను పొందడానికి ఉపయోగించటానికి అసలు కారణం ఏమిటంటే, URL అనేది వెబ్‌లో ఇచ్చిన డాక్యుమెంట్‌ను ఎక్కడ కనుగొనాలో మరియు ఎలా పొందాలి అని వివరించే ఒక రకమైన రెసిపీ.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"The URL consists of the name of a protocol, followed by the name of the machine where the document lives, and finishes with the path that names document on that machine.","translation":"URL ఒక ప్రోటోకాల్ పేరుతో మొదలవుతుంది, తరువాత డాక్యుమెంట్ ఉన్న మెషిన్ పేరుతో, ఆపై ఆ మెషిన్ లోని డాక్యుమెంట్‌ను సూచించే మార్గంతో ముగుస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"We will learn more about it in Section 2 of this book.","translation":"ఈ పుస్తకం యొక్క విభాగం 2 లో దీని గురించి మరింత తెలుసుకుంటాము.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"What, do you think, would it look like if we were to strip that layer of magic off—what if we wanted to use HTTP to directly fetch the result?","translation":"ఆ మాయాజాలాన్ని తీసివేస్తే ఎలా ఉంటుందో మీరు ఏమనుకుంటున్నారు—మనం ఫలితాన్ని నేరుగా పొందడానికి HTTP ని ఉపయోగించాలనుకుంటే ఏమిటి?","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"In this listing, all references to the idea of a URL have disappeared.","translation":"ఈ జాబితాలో, URL ఆలోచనకు సంబంధించిన అన్ని సూచనలు కనుమరుగయ్యాయి.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Instead, we are here directly manipulating the HTTP protocol.","translation":"బదులుగా, మేము ఇక్కడ నేరుగా HTTP ప్రోటోకాల్‌ను మారుస్తున్నాము.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"The result of running the program, however, is much the same as for the programs shown previously.","translation":"అయితే, ప్రోగ్రామ్‌ను అమలు చేయడం వల్ల వచ్చిన ఫలితం ఇంతకు ముందు చూపిన ప్రోగ్రామ్‌ల మాదిరిగానే ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"As we will see throughout this book, HTTP is just one of many protocols for which the Python Standard Library provides a built-in implementation.","translation":"ఈ పుస్తకం అంతటా మనం చూసినట్లుగా, పైథాన్ స్టాండర్డ్ లైబ్రరీ అంతర్నిర్మిత అమలును అందించే అనేక ప్రోటోకాల్‌లలో HTTP ఒకటి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"But, of course, HTTP cannot simply send data between two machines using thin air.","translation":"కానీ, వాస్తవానికి, HTTP గాలిని ఉపయోగించి రెండు కంప్యూటర్ల మధ్య డేటాను పంపించలేరు.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"In every previous program listing, we were using a Python library—written in Python itself—that knows how to speak a complicated network protocol on our behalf.","translation":"ప్రతి మునుపటి ప్రోగ్రామ్ జాబితాలో, మేము ఒక పైథాన్ లైబ్రరీని ఉపయోగిస్తున్నాము—పైథాన్ లోనే వ్రాయబడింది—ఇది మన తరపున ఒక సంక్లిష్టమైన నెట్‌వర్క్ ప్రోటోకాల్‌ను ఎలా మాట్లాడాలో తెలుసు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"You are even likely to see some of these private addresses in your own home.","translation":"మీ స్వంత ఇంట్లో కూడా మీరు ఈ ప్రైవేట్ చిరునామాలను చూసే అవకాశం ఉంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Your Linksys wireless router or DSL modem will often assign IP addresses from one of these private ranges to your home computers and laptops.","translation":"మీ Linksys వైర్‌లెస్ రూటర్ లేదా DSL మోడెమ్ తరచుగా మీ హోమ్ కంప్యూటర్లు మరియు ల్యాప్‌టాప్‌లకు ఈ ప్రైవేట్ శ్రేణులలో ఒకదాని నుండి IP చిరునామాలను కేటాయిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Routing So, operating systems that implement the Internet protocol allow programs to send messages whose destinations IP addresses—say, 8.8.4.4—and to deliver each packet, the operating system has to decide how to transmit it using one of the physical networks to which the machine is connected.","translation":"రౌటింగ్ కాబట్టి, ఇంటర్నెట్ ప్రోటోకాల్‌ను అమలు చేసే ఆపరేటింగ్ సిస్టమ్‌లు ప్రోగ్రామ్‌లు సందేశాలను పంపడానికి అనుమతిస్తాయి, వాటి గమ్యస్థాన IP చిరునామాలు—అంటే, 8.8.4.4—మరియు ప్రతి ప్యాకెట్‌ను అందించడానికి, ఆపరేటింగ్ సిస్టమ్ దానిని మెషిన్ కనెక్ట్ చేయబడిన భౌతిక నెట్‌వర్క్‌లలో ఒకదానిని ఉపయోగించి ఎలా ప్రసారం చేయాలో నిర్ణయించుకోవాలి.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"This decision—the decision of where to send each packet, based on the IP address that is its destination—is called routing.","translation":"ఈ నిర్ణయం—ప్రతి ప్యాకెట్‌ను ఎక్కడికి పంపాలి అనే నిర్ణయం, దాని గమ్యస్థానంగా ఉన్న IP చిరునామా ఆధారంగా—రౌటింగ్ అని పిలువబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Most, or perhaps all, of the Python code you write during your career will be running on hosts out at the very edge of the Internet.","translation":"మీ కెరీర్‌లో మీరు రాసే చాలా లేదా బహుశా మొత్తం పైథాన్ కోడ్ ఇంటర్నెట్ యొక్క అంచున ఉన్న హోస్ట్‌లలో నడుస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"For such machines, routing becomes a quite simple decision.","translation":"అటువంటి యంత్రాల కోసం, రౌటింగ్ చాలా సులభమైన నిర్ణయంగా మారుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"If the IP address looks like 127.*.*.*, then the operating system knows that the packet is destined for another application running on the same machine.","translation":"IP చిరునామా 127.*.*.*లాగా కనిపిస్తే, ప్యాకెట్ అదే మెషీన్‌లో నడుస్తున్న మరొక అప్లికేషన్ కోసం ఉద్దేశించబడిందని ఆపరేటింగ్ సిస్టమ్ తెలుసుకుంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Otherwise, your machine forwards the packet to a gateway machine that connects your local subnet to the rest of the Internet.","translation":"లేకపోతే, మీ మెషిన్ ప్యాకెట్‌ను మీ స్థానిక సబ్‌నెట్‌ను ఇంటర్నెట్‌కు మిగిలిన వాటికి కనెక్ట్ చేసే గేట్‌వే మెషిన్‌కు ఫార్వార్డ్ చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"It will then be up to the gateway machine to decide where to send the packet after that.","translation":"ఆ తర్వాత ప్యాకెట్‌ను ఎక్కడికి పంపించాలో గేట్‌వే మెషిన్ నిర్ణయించుకుంటుంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"You can imagine that routing decisions are much more complex for the dedicated network devices that form the Internet’s backbone!","translation":"ఇంటర్నెట్ యొక్క బ్యాక్‌బోన్‌ను ఏర్పరుచుకునే ప్రత్యేక నెట్‌వర్క్ పరికరాల కోసం రౌటింగ్ నిర్ణయాలు చాలా సంక్లిష్టంగా ఉంటాయని మీరు ఊహించవచ్చు!","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"There, on the hubs that connect entire continents, elaborate routing tables have to be constructed, consulted, and constantly updated in order to know that packets destined for Google go in one direction, but packets directed to a Yahoo IP address go in another, and that packets directed to your machine go in yet another.","translation":"అక్కడ, మొత్తం ఖండాలను కలిపే కేంద్రాలలో, Google కోసం ఉద్దేశించిన ప్యాకెట్‌లు ఒక దిశలో వెళతాయని తెలుసుకోవడానికి విస్తృతమైన రౌటింగ్ పట్టికలను నిర్మించాలి, సంప్రదించాలి మరియు నిరంతరం అప్‌డేట్ చేయాలి, అయితే Yahoo IP చిరునామాకు నిర్దేశించిన ప్యాకెట్‌లు మరొకదానికి వెళతాయి మరియు మీ మెషిన్‌కు నిర్దేశించిన ప్యాకెట్‌లు మరొకదానికి వెళతాయి.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"But it is very rare for Python applications to run on Internet backbone routers, so the simpler routing situation just outlined is nearly always the one you will see in action.","translation":"కానీ ఇంటర్నెట్ బ్యాక్‌బోన్ రూటర్‌లలో పైథాన్ అప్లికేషన్‌లు అమలు చేయడం చాలా అరుదు, కాబట్టి ఇప్పుడే వివరించిన సాధారణ రౌటింగ్ పరిస్థితి దాదాపు ఎల్లప్పుడూ మీరు చర్యలో చూసేది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"To illustrate the idea of a subnet, all of whose hosts share the same IP address prefix, I have been writing the prefix followed by asterisks for the parts of the address that could vary.","translation":"సబ్‌నెట్ ఆలోచనను వివరించడానికి, దాని హోస్ట్‌లన్నీ ఒకే IP చిరునామా ఉపసర్గను కలిగి ఉంటాయి, చిరునామాలోని మారగల భాగాల కోసం నేను ఉపసర్గను నక్షత్రాలతో వ్రాస్తున్నాను.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Instead, subnets are specified by combining an IP address with a mask that indicates how many of its most significant bits have to match to make a host belong to that subnet.","translation":"బదులుగా, సబ్‌నెట్‌లు ఒక IP చిరునామాను మాస్క్‌తో కలిపి పేర్కొనబడతాయి, ఇది హోస్ట్ ఆ సబ్‌నెట్‌కు చెందినదిగా చేయడానికి ఎన్ని ముఖ్యమైన బిట్‌లు సరిపోలాలి అని సూచిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"If you keep in mind that every byte in an IP address represents eight bits of binary data, then you will be able to read subnet numbers very easily.","translation":"IP చిరునామాలోని ప్రతి బైట్ బైనరీ డేటా యొక్క ఎనిమిది బిట్‌లను సూచిస్తుందని మీరు గుర్తుంచుకుంటే, మీరు సబ్‌నెట్ నంబర్‌లను చాలా సులభంగా చదవగలరు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"This pattern, which describes the IP address range that we discussed previously, which is reserved for the local host, specifies that the first eight bits (one byte) must match the number 127, and that the remaining 24 bits (three bytes) can have any value they want.","translation":"ఈ నమూనా, మనం ఇంతకు ముందు చర్చించిన IP చిరునామా పరిధిని వివరిస్తుంది, ఇది స్థానిక హోస్ట్ కోసం రిజర్వ్ చేయబడింది, మొదటి ఎనిమిది బిట్‌లు (ఒక బైట్) 127 నంబర్‌తో సరిపోలాలి మరియు మిగిలిన 24 బిట్‌లు (మూడు బైట్‌లు) వారికి కావలసిన ఏదైనా విలువను కలిగి ఉండవచ్చు అని పేర్కొంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"This pattern will match any IP address that belongs in the private 192.168 range, because the first 16 bits must match perfectly.","translation":"ఈ నమూనా ప్రైవేట్ 192.168 పరిధికి చెందిన ఏదైనా IP చిరునామాతో సరిపోతుంది, ఎందుకంటే మొదటి 16 బిట్‌లు ఖచ్చితంగా సరిపోలాలి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"This leaves 256 unique addresses.","translation":"ఇది 256 ప్రత్యేక చిరునామాలను వదిలివేస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Typically, the .0 address is used as the name of the subnet, and the .255 address is used to create a “broadcast packet” that addresses all of the hosts on the subnet (as we will see in the next chapter), which leaves 254 addresses free to actually be assigned to computers.","translation":"సాధారణంగా, .0 చిరునామాను సబ్‌నెట్ పేరుగా ఉపయోగిస్తారు మరియు .255 చిరునామాను సబ్‌నెట్‌లోని అన్ని హోస్ట్‌లను పరిష్కరించే “ప్రసార ప్యాకెట్”ను రూపొందించడానికి ఉపయోగిస్తారు (మేము తదుపరి అధ్యాయంలో చూస్తాము), ఇది కంప్యూటర్‌లకు కేటాయించడానికి 254 చిరునామాలను ఉచితంగా ఉంచుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"In nearly all cases, your Python code will simply rely on its host operating system to make packet routing choices correctly—just as it lets the operating system resolve host names to IP addresses in the first place.","translation":"దాదాపు అన్ని సందర్భాల్లో, మీ పైథాన్ కోడ్ ప్యాకెట్ రౌటింగ్ ఎంపికలను సరిగ్గా చేయడానికి దాని హోస్ట్ ఆపరేటింగ్ సిస్టమ్‌పై ఆధారపడుతుంది—ఆపరేటింగ్ సిస్టమ్ హోస్ట్ పేర్లను మొదట IP చిరునామాలకు పరిష్కరించడానికి అనుమతించినట్లే.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Turning on broadcast for a UDP socket does not disable or change its normal ability to send and receive specifically addressed packets.","translation":"ఒక UDP సాకెట్ కోసం ప్రసారం ఆన్ చేయడం వలన నిర్దిష్టంగా పరిష్కరించబడిన ప్యాకెట్‌లను పంపడానికి మరియు స్వీకరించడానికి దాని సాధారణ సామర్థ్యాన్ని నిలిపివేయదు లేదా మార్చదు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The magic happens when you view the settings for your local network, and use its IP “broadcast address” as the destination for the client.","translation":"మీరు మీ స్థానిక నెట్‌వర్క్ కోసం సెట్టింగ్‌లను చూసినప్పుడు మరియు దాని IP “ప్రసార చిరునామా”ని క్లయింట్ కోసం గమ్యస్థానంగా ఉపయోగించినప్పుడు మాయాజాలం జరుగుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"First bring up one or two servers on your network, using commands like the following: $ python udp_broadcast.py server Listening for broadcasts at ('0.0.0.0', 1060)","translation":"ముందుగా, కింది ఆదేశాలను ఉపయోగించి మీ నెట్‌వర్క్‌లో ఒకటి లేదా రెండు సర్వర్‌లను తీసుకురండి: $ python udp_broadcast.py server ('0.0.0.0', 1060) వద్ద ప్రసారాల కోసం వినండి","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"You will see that only one server gets each message: $ python udp_broadcast.py client 192.168.5.10","translation":"ప్రతి సందేశాన్ని ఒకే సర్వర్ పొందుతుందని మీరు చూస్తారు: $ python udp_broadcast.py client 192.168.5.10","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"But when you use the local network’s broadcast address, suddenly you will see that all of the broadcast servers get the packet at the same time!","translation":"కానీ మీరు స్థానిక నెట్‌వర్క్ యొక్క ప్రసార చిరునామాను ఉపయోగించినప్పుడు, ప్రసార సర్వర్లన్నీ ఒకే సమయంలో ప్యాకెట్‌ను పొందుతాయని మీరు అకస్మాత్తుగా చూస్తారు!","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"In case your operating system makes it difficult to determine the broadcast address, and you do not mind doing a broadcast out of every single network port of your host, Python lets you use the special hostname '<broadcast>' when sending with a UDP socket.","translation":"మీ ఆపరేటింగ్ సిస్టమ్ ప్రసార చిరునామాను గుర్తించడం కష్టతరం చేస్తే మరియు మీ హోస్ట్ యొక్క ప్రతి నెట్‌వర్క్ పోర్ట్ నుండి ప్రసారం చేయడానికి మీకు అభ్యంతరం లేకపోతే, UDP సాకెట్‌తో పంపేటప్పుడు ప్రత్యేక హోస్ట్ పేరు '<broadcast>'ని ఉపయోగించడానికి Python మిమ్మల్ని అనుమతిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Be careful to quote that name when passing it to our client, since the < and > characters are quite special to any normal POSIX shell: $ python udp_broadcast.py client \"<broadcast>\"","translation":"ఆ పేరును మా క్లయింట్‌కు పంపేటప్పుడు జాగ్రత్తగా ఉదహరించండి, ఎందుకంటే < మరియు > అక్షరాలు ఏదైనా సాధారణ POSIX షెల్‌కు చాలా ప్రత్యేకమైనవి: $ python udp_broadcast.py client \"<broadcast>\"","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"You might think that UDP would be very efficient for sending small messages.","translation":"చిన్న సందేశాలను పంపడానికి UDP చాలా సమర్థవంతంగా ఉంటుందని మీరు అనుకోవచ్చు.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Actually, UDP is efficient only if your host ever only sends one message at a time, then waits for a response.","translation":"వాస్తవానికి, మీ హోస్ట్ ఒకేసారి ఒక సందేశాన్ని మాత్రమే పంపితే, అప్పుడు ప్రతిస్పందన కోసం ఎదురు చూస్తే మాత్రమే UDP సమర్థవంతంగా ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"There are two good reasons to use UDP: Because you are implementing a protocol that already exists, and it uses UDP.","translation":"UDPని ఉపయోగించడానికి రెండు మంచి కారణాలు ఉన్నాయి: మీరు ఇప్పటికే ఉన్న ప్రోటోకాల్‌ను అమలు చేస్తున్నందున మరియు ఇది UDPని ఉపయోగిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The User Data Protocol, UDP, lets user-level programs send individual packets across an IP network.","translation":"యూజర్ డేటా ప్రోటోకాల్, UDP, వినియోగదారు-స్థాయి ప్రోగ్రామ్‌లు IP నెట్‌వర్క్ ద్వారా వ్యక్తిగత ప్యాకెట్‌లను పంపడానికి అనుమతిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The POSIX network stack gives you access to UDP through the idea of a “socket,” which is a communications endpoint that can sit at an IP address and UDP port number—these two things together are called the socket’s “name”—and send and receive UDP packets.","translation":"POSIX నెట్‌వర్క్ స్టాక్ మీకు “సాకెట్” అనే ఆలోచన ద్వారా UDPని యాక్సెస్ చేయడానికి అందిస్తుంది, ఇది ఒక కమ్యూనికేషన్ ఎండ్‌పాయింట్, ఇది IP చిరునామా మరియు UDP పోర్ట్ నంబర్‌తో కూర్చుని ఉంటుంది—ఈ రెండు విషయాలను కలిపి సాకెట్ యొక్క “పేరు” అంటారు—మరియు UDP ప్యాకెట్‌లను పంపండి మరియు స్వీకరించండి.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Clients have to compensate for this by being willing to re-transmit a request until they receive a reply.","translation":"ప్రత్యుత్తరం వచ్చే వరకు అభ్యర్థనను తిరిగి ప్రసారం చేయడానికి సిద్ధంగా ఉండటం ద్వారా క్లయింట్‌లు దీనిని భర్తీ చేయాలి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Request IDs are crucial to combat the problem of reply duplication, where a reply you thought was lost arrives later after all and could be mistaken for the reply to your current question.","translation":"ప్రత్యుత్తరం నకిలీ సమస్యను ఎదుర్కోవడానికి అభ్యర్థన IDలు చాలా కీలకం, ఇక్కడ మీరు కోల్పోయారని అనుకున్న ప్రత్యుత్తరం తరువాత వస్తుంది మరియు మీ ప్రస్తుత ప్రశ్నకు ప్రత్యుత్తరంగా పొరపాటు పడవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Among the socket options available for UDP sockets, the most powerful is broadcast, which lets you send packets to every host on your subnet without having to send to each host individually.","translation":"UDP సాకెట్‌ల కోసం అందుబాటులో ఉన్న సాకెట్ ఎంపికలలో, అత్యంత శక్తివంతమైనది ప్రసారం, ఇది ప్రతి హోస్ట్‌కు వ్యక్తిగతంగా పంపకుండా మీ సబ్‌నెట్‌లోని ప్రతి హోస్ట్‌కు ప్యాకెట్‌లను పంపడానికి మిమ్మల్ని అనుమతిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Rather than running very slowly in lock-step by needing every packet to be acknowledged before it sends the next one, TCP sends whole bursts of packets at a time before expecting a response.","translation":"తదుపరి ప్యాకెట్‌ను పంపడానికి ముందు ప్రతి ప్యాకెట్‌ను గుర్తించాల్సిన అవసరం ద్వారా చాలా నెమ్మదిగా లాక్-స్టెప్‌లో నడుస్తున్న బదులు, TCP ప్రతిస్పందనను ఆశించే ముందు ఒకేసారి ప్యాకెట్‌ల మొత్తాన్ని పంపుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"The TCP implementation on the receiving end can regulate the window size of the transmitting end, and thus slow or pause the connection.","translation":"స్వీకరించే చివరన ఉన్న TCP అమలు ప్రసారం చేసే చివర యొక్క విండో పరిమాణాన్ని నియంత్రించగలదు మరియు తద్వారా కనెక్షన్‌ను నెమ్మదిస్తుంది లేదా పాజ్ చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"This is impossible with TCP, and so UDP is often the foundation of live-streaming multimedia over the Internet.","translation":"ఇది TCPతో అసాధ్యం, కాబట్టి ఇంటర్నెట్‌లో లైవ్-స్ట్రీమింగ్ మల్టీమీడియాకు UDP తరచుగా ఆధారం.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"As we saw in the previous chapter, it takes only a single socket to speak UDP: a server can open a datagram port and then receive packets from thousands of different clients.","translation":"మునుపటి అధ్యాయంలో మనం చూసినట్లుగా, UDP మాట్లాడటానికి ఒకే సాకెట్ మాత్రమే పడుతుంది: ఒక సర్వర్ డేటాగ్రామ్ పోర్ట్‌ను తెరవగలదు మరియు వేలాది మంది వేర్వేరు క్లయింట్‌ల నుండి ప్యాకెట్‌లను స్వీకరించగలదు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"But with a stateful stream protocol like TCP, the connect() call becomes the fundamental act upon which all other network communication hinges.","translation":"కానీ TCP వంటి స్టేట్‌ఫుల్ స్ట్రీమ్ ప్రోటోకాల్‌తో, కనెక్ట్() కాల్ అన్ని ఇతర నెట్‌వర్క్ కమ్యూనికేషన్ ఆధారపడే ప్రాథమిక చర్యగా మారుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"If your application runs off and tries to use DNS on its own as its first choice for resolving a domain name, then users will notice that some computer names that work everywhere else on your system—in their browser, in file share names, and so forth—suddenly do not work when they use your application, because you are not deferring to mechanisms like WINS or /etc/hosts like the operating system itself does.","translation":"మీ అప్లికేషన్ డొమైన్ పేరును పరిష్కరించడానికి DNSని మొదటి ఎంపికగా ఉపయోగిస్తే, మీ సిస్టమ్‌లో ప్రతిచోటా పనిచేసే కొన్ని కంప్యూటర్ పేర్లు—వాటి బ్రౌజర్‌లో, ఫైల్ షేర్ పేర్లలో మొదలైనవి—మీరు మీ అప్లికేషన్‌ను ఉపయోగిస్తున్నప్పుడు అకస్మాత్తుగా పని చేయవు, ఎందుకంటే మీరు WINS లేదా /etc/hosts వంటి విధానాలకు వాయిదా వేయడం లేదు, ఆపరేటింగ్ సిస్టమ్ చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"The DNS is often not the only way that a system gets name information.","translation":"DNS తరచుగా సిస్టమ్ పేరు సమాచారాన్ని పొందే ఏకైక మార్గం కాదు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The local machine probably has a cache of recently queried domain names that might already know about the host whose IP address you need.","translation":"స్థానిక మెషీన్ ఇటీవల ప్రశ్నించబడిన డొమైన్ పేర్ల కాష్‌ని కలిగి ఉండవచ్చు, మీకు అవసరమైన హోస్ట్ యొక్క IP చిరునామా గురించి ఇది ఇప్పటికే తెలిసి ఉండవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"If you try speaking DNS yourself to answer your query, you will be duplicating work that has already been done.","translation":"మీరు మీ ప్రశ్నలకు సమాధానం ఇవ్వడానికి DNSని మీరే మాట్లాడటానికి ప్రయత్నిస్తే, ఇప్పటికే చేసిన పనిని మీరు నకిలీ చేస్తారు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The system on which your Python script is running already knows about the local domain nameservers.","translation":"మీ పైథాన్ స్క్రిప్ట్ నడుస్తున్న సిస్టమ్ ఇప్పటికే స్థానిక డొమైన్ నేమ్‌సర్వర్‌ల గురించి తెలుసు.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"To crank up DNS right inside your Python program, you will have to learn how to query your particular operating system for this information.","translation":"మీ పైథాన్ ప్రోగ్రామ్‌లో DNSని పెంచడానికి, ఈ సమాచారం కోసం మీ నిర్దిష్ట ఆపరేటింగ్ సిస్టమ్‌ను ఎలా ప్రశ్నించాలో మీరు తెలుసుకోవాలి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"If you do not use the local DNS server, then you will not be able to benefit from its own cache.","translation":"మీరు స్థానిక DNS సర్వర్‌ను ఉపయోగించకపోతే, మీరు దాని స్వంత కాష్ నుండి ప్రయోజనం పొందలేరు.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"From time to time, adjustments are made to the world DNS infrastructure.","translation":"సమయం నుండి సమయానికి, ప్రపంచ DNS మౌలిక సదుపాయాలకు సర్దుబాట్లు చేయబడతాయి.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"If your program makes raw DNS calls of its own, then you will have to follow these changes yourself.","translation":"మీ ప్రోగ్రామ్ దాని స్వంత ముడి DNS కాల్‌లు చేస్తే, మీరు ఈ మార్పులను మీరే అనుసరించాలి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Finally, note that Python does not come with any DNS facilities built into the Standard Library.","translation":"చివరగా, పైథాన్ స్టాండర్డ్ లైబ్రరీలో నిర్మించిన DNS సౌకర్యాలతో రాదని గమనించండి.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"There is, however, a solid and legitimate reason to make a DNS call from Python: because you are a mail server.","translation":"అయితే, పైథాన్ నుండి DNS కాల్ చేయడానికి ఒక ఘనమైన మరియు చట్టబద్ధమైన కారణం ఉంది: ఎందుకంటే మీరు మెయిల్ సర్వర్.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"We will focus on the slightly more popular distribution, pydns.","translation":"మేము కొంచెం ఎక్కువ ప్రజాదరణ పొందిన పంపిణీ, pydns పై దృష్టి పెడతాము.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"It makes a DNS package available for you to import.","translation":"ఇది దిగుమతి చేసుకోవడానికి మీకు DNS ప్యాకేజీని అందుబాటులో ఉంచుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Both distributions have seen updates within the past year.","translation":"గత సంవత్సరంలో రెండు పంపిణీలు నవీకరణలను చూశాయి.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Neither project provides code that knows how to “start from scratch” and begin a query with a search of the Internet root domain nameservers!","translation":"ఏ ప్రాజెక్ట్ కూడా ","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Your Python interpreter will then gain the ability to run our first DNS program listing.","translation":"అప్పుడు మీ పైథాన్ ఇంటర్‌ప్రెటర్ మా మొదటి DNS ప్రోగ్రామ్ జాబితాను అమలు చేసే సామర్థ్యాన్ని పొందుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Neither package seems to have any real documentation.","translation":"ఏ ప్యాకేజీకి నిజమైన డాక్యుమెంటేషన్ ఉన్నట్లు అనిపించదు.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"As you can see from the program, each “answer” in the reply that has been returned is represented by a dictionary in pydns.","translation":"మీరు ప్రోగ్రామ్ నుండి చూడగలిగినట్లుగా, తిరిగి వచ్చిన ప్రతిస్పందనలోని ప్రతి “సమాధానం” pydnsలో నిఘంటువు ద్వారా సూచించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The name that we looked up.","translation":"మేము వెతికిన పేరు.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Sending e-mail to a domain is a completely different act from trying to make an HTTP or SSH connection to a domain.","translation":"డొమైన్‌కు ఇమెయిల్ పంపడం అనేది డొమైన్‌కు HTTP లేదా SSH కనెక్షన్‌ను చేయడానికి ప్రయత్నించడం కంటే పూర్తిగా భిన్నమైన చర్య.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The client and server simply sent their messages, and then could close their sockets separately without needing to do any further checks.","translation":"క్లయింట్ మరియు సర్వర్ వారి సందేశాలను పంపారు, ఆ తర్వాత ఎలాంటి తనిఖీలు చేయకుండానే వారి సాకెట్‌లను విడిగా మూసివేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"But in Listing 3–2, the client sends—and thus the server also processes and sends back—an arbitrary amount of data whose length is not decided until the user enters a number of bytes on the command line.","translation":"కానీ జాబితా 3–2లో, క్లయింట్ పంపుతుంది—అలాగే సర్వర్ కూడా ప్రాసెస్ చేసి తిరిగి పంపుతుంది—వినియోగదారుడు కమాండ్ లైన్‌లో ఎన్ని బైట్‌లను నమోదు చేసే వరకు నిర్ణయించబడని డేటా మొత్తాన్ని.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"The solution is to “half-close” the socket—that is, to permanently shut down communication in one direction but without destroying the socket itself—so that the server can no longer read any data, but can still send any remaining reply back in the other direction, which will still be open.","translation":"పరిష్కారం ఏమిటంటే సాకెట్‌ను “అర్ధ-మూసివేయడం”—అంటే, ఒక దిశలో కమ్యూనికేషన్‌ను శాశ్వతంగా మూసివేయడం, కానీ సాకెట్‌ను నాశనం చేయకుండా—అందువల్ల సర్వర్ ఇకపై ఎలాంటి డేటాను చదవలేకపోతుంది, కానీ మిగిలిన ప్రత్యుత్తరాన్ని ఇతర దిశలో పంపవచ్చు, ఇది ఇప్పటికీ తెరిచే ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"SHUT_WR: This is the most common value used, since in most cases a program knows when its own output is finished but not about when its conversation partner will be done.","translation":"SHUT_WR: ఇది సాధారణంగా ఉపయోగించే విలువ, ఎందుకంటే చాలా సందర్భాల్లో ఒక ప్రోగ్రామ్ దాని స్వంత అవుట్‌పుట్ ఎప్పుడు పూర్తవుతుందో తెలుసు, కానీ దాని సంభాషణ భాగస్వామి ఎప్పుడు పూర్తవుతుందో తెలియదు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"This closes communication in both directions on the socket.","translation":"ఇది సాకెట్‌పై రెండు దిశలలో కమ్యూనికేషన్‌ను మూసివేస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Since TCP supports streams of data, they might have already reminded you of normal files, which also support reading and writing as fundamental operations.","translation":"TCP డేటా స్ట్రీమ్‌లకు మద్దతు ఇస్తుంది కాబట్టి, అవి ఇప్పటికే సాధారణ ఫైల్‌లను గుర్తుకు తెచ్చి ఉండవచ్చు, ఇవి ప్రాథమిక కార్యకలాపాలుగా చదవడం మరియు రాయడానికి కూడా మద్దతు ఇస్తాయి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Python does a very good job of keeping these concepts separate: file objects can read() and write(), sockets can send() and recv(), and no kind of object can do both.","translation":"ఈ భావనలను వేరుగా ఉంచడంలో పైథాన్ చాలా మంచి పని చేస్తుంది: ఫైల్ ఆబ్జెక్ట్‌లు read() మరియు write() చేయగలవు, సాకెట్‌లు send() మరియు recv() చేయగలవు మరియు ఏ రకమైన వస్తువు రెండూ చేయలేవు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"For this purpose, Python provides a makefile() method on every socket that returns a Python file object that is really calling recv() and send() behind the scenes:","translation":"ఈ ప్రయోజనం కోసం, పైథాన్ ప్రతి సాకెట్‌పై makefile() పద్ధతిని అందిస్తుంది, ఇది నిజంగా తెర వెనుక recv() మరియు send()ని పిలిచే పైథాన్ ఫైల్ ఆబ్జెక్ట్‌ను అందిస్తుంది:","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The TCP-powered “stream” socket does whatever is necessary—including re-transmitting lost packets, reordering the ones that arrive out of sequence, and splitting very large data streams into optimally sized packets for your network in the first place—to support the transmission and reception of streams of data over the network between two sockets.","translation":"TCP-శక్తితో నడిచే “స్ట్రీమ్” సాకెట్ కోల్పోయిన ప్యాకెట్‌లను తిరిగి పంపడం, క్రమం తప్పకుండా వచ్చే వాటిని తిరిగి ఆర్డర్ చేయడం మరియు చాలా పెద్ద డేటా స్ట్రీమ్‌లను మీ నెట్‌వర్క్ కోసం సరైన పరిమాణంలో ప్యాకెట్‌లుగా విభజించడం వంటివి చేస్తుంది—రెండు సాకెట్‌ల మధ్య నెట్‌వర్క్ ద్వారా డేటా స్ట్రీమ్‌ల ప్రసారం మరియు స్వీకరణకు మద్దతు ఇవ్వడానికి.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"As with UDP, port numbers are used by TCP to distinguish the many stream endpoints that might exist on a single machine.","translation":"UDP వలె, ఒకే యంత్రంలో ఉండగలిగే అనేక స్ట్రీమ్ ఎండ్‌పాయింట్‌లను వేరు చేయడానికి TCP ద్వారా పోర్ట్ నంబర్‌లు ఉపయోగించబడతాయి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"A program that wants to accept incoming TCP connections needs to bind() to a port, run listen() on the socket, and then go into a loop that runs accept() over and over to receive a new socket for each incoming connection with which it can talk to each particular client that connects.","translation":"ఇన్‌కమింగ్ TCP కనెక్షన్‌లను అంగీకరించాలనుకునే ప్రోగ్రామ్ పోర్ట్‌కు bind() చేయాలి, సాకెట్‌పై listen()ని అమలు చేయాలి, ఆపై ప్రతి ఇన్‌కమింగ్ కనెక్షన్ కోసం కొత్త సాకెట్‌ను స్వీకరించడానికి accept()ని పదేపదే అమలు చేసే లూప్‌లోకి వెళ్ళాలి, దానితో అది కనెక్ట్ అయ్యే ప్రతి నిర్దిష్ట క్లయింట్‌తో మాట్లాడగలదు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Servers will usually want to set the SO_REUSEADDR option on the sockets they bind(), lest old connections still closing down on the same port from the last time the server was run prevent the operating system from allowing the binding.","translation":"సర్వర్లు సాధారణంగా వారు bind() చేసే సాకెట్‌లపై SO_REUSEADDR ఎంపికను సెట్ చేయాలనుకుంటారు, లేకపోతే సర్వర్ చివరిసారిగా రన్ అయినప్పుడు అదే పోర్ట్‌పై మూసివేయబడే పాత కనెక్షన్‌లు ఆపరేటింగ్ సిస్టమ్ బంధించడానికి అనుమతించకుండా నిరోధిస్తాయి.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Data is actually sent and received with send() and recv().","translation":"డేటాను వాస్తవానికి send() మరియు recv()తో పంపబడుతుంది మరియు స్వీకరించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"The shutdown() socket method can be used to produce end-of-file in one direction on a socket (all sockets are bidirectional by nature) while leaving the other direction open.","translation":"shutdown() సాకెట్ పద్ధతిని సాకెట్‌పై ఒక దిశలో ఫైల్ ముగింపును ఉత్పత్తి చేయడానికి ఉపయోగించవచ్చు (అన్ని సాకెట్‌లు స్వభావరీత్యా ద్విదిశాత్మకమైనవి), అయితే ఇతర దిశను తెరిచి ఉంచుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Deadlock can occur if two peers are written such that the socket fills with more and more data that never gets read.","translation":"రెండు పీర్‌లు వ్రాయబడితే, సాకెట్ ఎప్పటికీ చదవబడని ఎక్కువ డేటాతో నిండిపోతే డెడ్‌లాక్ సంభవించవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"If you want to pass a socket to a Python routine that knows how to read to or write from a normal file object, the makefile() socket method will give you a Python object that calls recv() and send() behind the scenes when the caller needs to read and write.","translation":"మీరు సాధారణ ఫైల్ ఆబ్జెక్ట్ నుండి ఎలా చదవాలో లేదా ఎలా రాయాలో తెలిసిన పైథాన్ రొటీన్‌కు సాకెట్‌ను పంపాలనుకుంటే, makefile() సాకెట్ పద్ధతి మీకు పైథాన్ ఆబ్జెక్ట్‌ను అందిస్తుంది, ఇది కాలర్ చదవడానికి మరియు వ్రాయడానికి అవసరమైనప్పుడు తెర వెనుక recv() మరియు send()ని పిలుస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"In general, an FQDN may be used to identify a host from anywhere else on the Internet.","translation":"సాధారణంగా, ఇంటర్నెట్‌లో మరెక్కడి నుండైనా హోస్ట్‌ను గుర్తించడానికి FQDNని ఉపయోగించవచ్చు.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"While you might have been able to pick up some scattered facts about socket names from the last few chapters—like the fact that the first item can be either a hostname or a dotted IP address—it is time for us to approach the whole subject in more depth.","translation":"చివరి కొన్ని అధ్యాయాల నుండి సాకెట్ పేర్ల గురించి కొన్ని విషయాలు మీరు తెలుసుకుని ఉండవచ్చు—మొదటి అంశం హోస్ట్‌పేరు లేదా డాటెడ్ IP చిరునామా కావచ్చు—మనం మొత్తం విషయాన్ని మరింత లోతుగా పరిశీలించాల్సిన సమయం ఆసన్నమైంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"For your reference, here are all of the major socket methods that demand of you some sort of socket name as an argument:","translation":"మీ సూచన కోసం, ఇక్కడ కొన్ని సాకెట్ పేరును వాదనగా కోరే ప్రధాన సాకెట్ పద్ధతులు ఉన్నాయి:","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"In order, here is the full list of values that had to be chosen, and you will see that there are five in all.","translation":"క్రమంలో, ఎంచుకోవలసిన విలువల పూర్తి జాబితా ఇక్కడ ఉంది మరియు మొత్తం ఐదు ఉన్నాయని మీరు చూస్తారు.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"For example, an HTTP request often consists of headers, a blank line, and then however many further bytes of data were specified in the Content-length header.","translation":"ఉదాహరణకు, HTTP అభ్యర్థన తరచుగా హెడర్‌లు, ఖాళీ లైన్ మరియు కంటెంట్-లెంగ్త్ హెడర్‌లో పేర్కొన్న డేటా యొక్క మరిన్ని బైట్‌లను కలిగి ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"You would not know how many times to keep running recv() until you had at least received the headers and then parsed them to find out the content length!","translation":"మీరు కనీసం హెడర్‌లను స్వీకరించే వరకు మరియు కంటెంట్ పొడవును తెలుసుకోవడానికి వాటిని విశ్లేషించే వరకు recv()ని ఎన్నిసార్లు అమలు చేయాలో మీకు తెలియదు!","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Recall from our foregoing discussion that there are two very different kinds of stream sockets: listening sockets, with which servers make a port available for incoming connections, and connected sockets, which represent the conversation that a server is having with a particular client.","translation":"మునుపటి చర్చ నుండి గుర్తుకు తెచ్చుకోండి, రెండు రకాల స్ట్రీమ్ సాకెట్‌లు ఉన్నాయి: వినడానికి సాకెట్‌లు, దీనితో సర్వర్లు ఇన్‌కమింగ్ కనెక్షన్‌ల కోసం పోర్ట్‌ను అందుబాటులో ఉంచుతాయి మరియు కనెక్ట్ చేయబడిన సాకెట్‌లు, ఇవి ఒక నిర్దిష్ట క్లయింట్‌తో సర్వర్ చేస్తున్న సంభాషణను సూచిస్తాయి.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"In Listing 3–1, you can see how this distinction is carried through in actual server code.","translation":"లిస్టింగ్ 3–1లో, ఈ వ్యత్యాసం వాస్తవ సర్వర్ కోడ్‌లో ఎలా కొనసాగుతుందో మీరు చూడవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The link, which might strike you as odd at first, is that a listening socket actually produces new connected sockets as the return value that you get by listening!","translation":"మొదట విచిత్రంగా అనిపించే లింక్ ఏమిటంటే, వినడానికి సాకెట్ వాస్తవానికి వినడం ద్వారా మీరు పొందే రిటర్న్ విలువగా కొత్త కనెక్ట్ చేయబడిన సాకెట్‌లను ఉత్పత్తి చేస్తుంది!","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"First, the server runs bind() to claim a particular port.","translation":"ముందుగా, సర్వర్ నిర్దిష్ట పోర్ట్‌ను క్లెయిమ్ చేయడానికి bind()ని అమలు చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Note that this does not yet decide whether the socket will be a client or server socket—that is, whether it will be actively making a connection or passively waiting to receive incoming connections.","translation":"సాకెట్ క్లయింట్ లేదా సర్వర్ సాకెట్ అవుతుందా అని ఇది ఇంకా నిర్ణయించలేదు—అంటే, ఇది చురుకుగా కనెక్షన్ చేస్తుందా లేదా ఇన్‌కమింగ్ కనెక్షన్‌లను స్వీకరించడానికి నిష్క్రియంగా వేచి ఉంటుందా.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Clients can use this call if, for some reason, they want to reach out to a server from a particular port on their machine rather than simply accepting whatever ephemeral port number they would otherwise be assigned.","translation":"కొన్ని కారణాల వల్ల, క్లయింట్‌లు తమ మెషీన్‌లోని నిర్దిష్ట పోర్ట్ నుండి సర్వర్‌ను సంప్రదించాలనుకుంటే, వారు కేటాయించబడే తాత్కాలిక పోర్ట్ నంబర్‌ను స్వీకరించడానికి బదులుగా ఈ కాల్‌ని ఉపయోగించవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"The real moment of decision comes with the next method call, when the server announces that it wants to use the socket to listen().","translation":"నిజమైన నిర్ణయం తదుపరి పద్ధతి కాల్‌తో వస్తుంది, సర్వర్ సాకెట్‌ను వినడానికి ఉపయోగించాలనుకుంటున్నట్లు ప్రకటించినప్పుడు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Running this on a TCP socket utterly transforms its character: after listen() has been called, the socket is irrevocably changed and can never, from this point on, be used to send or receive data.","translation":"దీన్ని TCP సాకెట్‌లో అమలు చేయడం దాని స్వభావాన్ని పూర్తిగా మారుస్తుంది: listen()ని పిలిచిన తర్వాత, సాకెట్ కోలుకోలేని విధంగా మార్చబడుతుంది మరియు ఈ సమయంలో డేటాను పంపడానికి లేదా స్వీకరించడానికి ఎప్పటికీ ఉపయోగించబడదు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Instead, the socket can now be used only to receive incoming connections through its accept() method—a method that we have not seen yet in this book, because its purpose is solely to support listening TCP sockets—and each of these calls waits for a new client to connect and then returns an entirely new socket that governs the new conversation that has just started with them!","translation":"బదులుగా, సాకెట్‌ను ఇప్పుడు దాని accept() పద్ధతి ద్వారా ఇన్‌కమింగ్ కనెక్షన్‌లను స్వీకరించడానికి మాత్రమే ఉపయోగించవచ్చు—ఈ పుస్తకంలో మనం ఇంకా చూడని ఒక పద్ధతి, ఎందుకంటే దాని ఉద్దేశ్యం వినడానికి TCP సాకెట్‌లకు మాత్రమే మద్దతు ఇవ్వడం—మరియు ఈ కాల్‌లలో ప్రతి ఒక్కటి కొత్త క్లయింట్ కనెక్ట్ అవ్వడానికి వేచి ఉంటుంది మరియు ఆపై వారితో ఇప్పుడే ప్రారంభమైన కొత్త సంభాషణను నియంత్రించే పూర్తిగా కొత్త సాకెట్‌ను అందిస్తుంది!","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"As you can see from the code, getsockname() works fine against both listening and connected sockets, and in both cases lets you find out what local TCP port the socket is occupying.","translation":"మీరు కోడ్ నుండి చూడగలిగినట్లుగా, getsockname() వినడానికి మరియు కనెక్ట్ చేయబడిన సాకెట్‌లకు వ్యతిరేకంగా బాగా పనిచేస్తుంది మరియు రెండు సందర్భాల్లోనూ సాకెట్ ఏ స్థానిక TCP పోర్ట్‌ను ఆక్రమిస్తుందో తెలుసుకోవడానికి మిమ్మల్ని అనుమతిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"To learn the address of the client to which a connected socket is connected, you can at any time run the getpeername() method, or you can store the socket name that is returned as the second return value from accept().","translation":"కనెక్ట్ చేయబడిన సాకెట్ కనెక్ట్ చేయబడిన క్లయింట్ యొక్క చిరునామాను తెలుసుకోవడానికి, మీరు ఎప్పుడైనా getpeername() పద్ధతిని అమలు చేయవచ్చు లేదా accept() నుండి రెండవ రిటర్న్ విలువగా తిరిగి వచ్చే సాకెట్ పేరును నిల్వ చేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"When we run this server, we see that both values give us the same address: $ python tcp_sixteen.py server Listening at ('127.0.0.1', 1060) We have accepted a connection from ('127.0.0.1', 58185) Socket connects ('127.0.0.1', 1060) and ('127.0.0.1', 58185) The incoming sixteen-octet message says 'Hi there, server' Reply sent, socket closed Listening at ('127.0.0.1', 1060)","translation":"మేము ఈ సర్వర్‌ను అమలు చేసినప్పుడు, రెండు విలువలు మాకు ఒకే చిరునామాను ఇస్తున్నాయని మేము చూస్తాము: $ python tcp_sixteen.py server Listening at ('127.0.0.1', 1060) We have accepted a connection from ('127.0.0.1', 58185) Socket connects ('127.0.0.1', 1060) and ('127.0.0.1', 58185) The incoming sixteen-octet message says 'Hi there, server' Reply sent, socket closed Listening at ('127.0.0.1', 1060)","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"The foregoing example output is produced by having the client make one connection to the server, like this: $ python tcp_sixteen.py client Client has been assigned socket name ('127.0.0.1', 58185) The server said 'Farewell, client'","translation":"మునుపటి ఉదాహరణ అవుట్‌పుట్ క్లయింట్ సర్వర్‌కు ఒక కనెక్షన్ చేసినప్పుడు ఉత్పత్తి అవుతుంది, ఈ విధంగా: $ python tcp_sixteen.py client Client has been assigned socket name ('127.0.0.1', 58185) The server said 'Farewell, client'","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"You can see from the rest of the server code that, once a connected socket has been returned by accept(), it works exactly like a client socket with no further asymmetries evident in their pattern of communication.","translation":"మిగిలిన సర్వర్ కోడ్ నుండి మీరు చూడగలిగినట్లుగా, accept() ద్వారా కనెక్ట్ చేయబడిన సాకెట్ తిరిగి వచ్చిన తర్వాత, ఇది కమ్యూనికేషన్ నమూనాలో మరింత అసమానతలు లేకుండా క్లయింట్ సాకెట్ లాగా ఖచ్చితంగా పనిచేస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"The recv() call returns data as it becomes available, and sendall() is the best way to send a new string of data when you want to make sure that it all gets transmitted.","translation":"recv() కాల్ అందుబాటులోకి వచ్చినప్పుడు డేటాను అందిస్తుంది మరియు మీరు అంతా ప్రసారం చేయబడిందని నిర్ధారించుకోవాలనుకున్నప్పుడు కొత్త డేటా స్ట్రింగ్‌ను పంపడానికి sendall() ఉత్తమ మార్గం.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"You will note that an integer argument was provided to listen() when it was called on the server socket.","translation":"సర్వర్ సాకెట్‌లో పిలిచినప్పుడు listen()కి పూర్ణాంక వాదన అందించబడిందని మీరు గమనించాలి.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"This number indicates how many waiting connections, which have not yet had sockets created for them by accept() calls, should be allowed to stack up before the operating system starts turning new connections away by returning connection errors.","translation":"ఈ సంఖ్య ఎన్ని నిరీక్షణ కనెక్షన్‌లను సూచిస్తుంది, ఇవి accept() కాల్‌ల ద్వారా వాటి కోసం ఇంకా సాకెట్‌లను సృష్టించలేదు, ఆపరేటింగ్ సిస్టమ్ కనెక్షన్ లోపాలను తిరిగి ఇవ్వడం ద్వారా కొత్త కనెక్షన్‌లను తిరస్కరించడం ప్రారంభించే ముందు పేరుకుపోవడానికి అనుమతించాలి.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"We are using the very small value 1 here in our examples because we support only one example client connecting at a time; but we will consider larger values for this call when we talk about network server design in Chapter 7.","translation":"మేము ఇక్కడ మా ఉదాహరణలలో చాలా చిన్న విలువ 1ని ఉపయోగిస్తున్నాము, ఎందుకంటే మేము ఒకే ఉదాహరణ క్లయింట్ ఒకేసారి కనెక్ట్ అవ్వడానికి మద్దతు ఇస్తున్నాము; కానీ మనం అధ్యాయం 7లో నెట్‌వర్క్ సర్వర్ డిజైన్ గురించి మాట్లాడేటప్పుడు ఈ కాల్ కోసం పెద్ద విలువలను పరిగణనలోకి తీసుకుంటాము.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"You can see that supplying the IPv4 address for the localhost locks you down to receiving connections only over IPv4.","translation":"localhost కోసం IPv4 చిరునామాను అందించడం వలన మీరు IPv4 ద్వారా మాత్రమే కనెక్షన్లను స్వీకరించడానికి పరిమితం చేయబడతారు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"One question that you might already be asking at this point, by the way, is what on earth you are supposed to do when you assert that you want to supply a basic service and getaddrinfo() goes and gives you several addresses to use.","translation":"మీరు ప్రాథమిక సేవను అందించాలని పేర్కొన్నప్పుడు మరియు getaddrinfo() ఉపయోగించడానికి అనేక చిరునామాలను ఇచ్చినప్పుడు మీరు ఏమి చేయాలో ఈ సమయంలో మీరు అడగవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"In Chapter 7, we will tackle the techniques that you can use if you are writing server code and want to have several sockets going at once.","translation":"అధ్యాయం 7లో, మీరు సర్వర్ కోడ్‌ను వ్రాస్తుంటే మరియు ఒకేసారి అనేక సాకెట్‌లను కలిగి ఉండాలనుకుంటే మీరు ఉపయోగించగల పద్ధతులను మేము చర్చిస్తాము.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The usual use of getaddrinfo() in all other cases—which, basically, is when you are preparing to connect() or sendto()—is to specify the AI_ADDRCONFIG flag, which filters out any addresses that are impossible for your computer to reach.","translation":"మిగిలిన అన్ని సందర్భాల్లో getaddrinfo() యొక్క సాధారణ ఉపయోగం—ప్రాథమికంగా, మీరు కనెక్ట్() లేదా sendto() కోసం సిద్ధమవుతున్నప్పుడు—AI_ADDRCONFIG ఫ్లాగ్‌ను పేర్కొనడం, ఇది మీ కంప్యూటర్ చేరుకోలేని ఏ చిరునామాలను అయినా ఫిల్టర్ చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"For example, an organization might have both an IPv4 and an IPv6 range of IP addresses; but if your particular host supports only IPv4, then you will want the results filtered to include only addresses in that family.","translation":"ఉదాహరణకు, ఒక సంస్థ IPv4 మరియు IPv6 IP చిరునామాల శ్రేణిని కలిగి ఉండవచ్చు; కానీ మీ నిర్దిష్ట హోస్ట్ IPv4ని మాత్రమే సపోర్ట్ చేస్తే, మీరు ఆ కుటుంబంలోని చిరునామాలను మాత్రమే చేర్చడానికి ఫలితాలను ఫిల్టర్ చేయాలనుకుంటున్నారు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"In case the local machine has only an IPv6 network interface but the service you are connecting to is supporting only IPv4, the AI_V4MAPPED will return you those IPv4 addresses re-encoded as IPv6 addresses that you can actually use.","translation":"స్థానిక మెషీన్‌లో IPv6 నెట్‌వర్క్ ఇంటర్‌ఫేస్ మాత్రమే ఉన్న సందర్భంలో, మీరు కనెక్ట్ అవుతున్న సేవ IPv4ని మాత్రమే సపోర్ట్ చేస్తే, AI_V4MAPPED మీకు ఆ IPv4 చిరునామాలను మీరు వాస్తవానికి ఉపయోగించగల IPv6 చిరునామాలుగా మారుస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"And we have gotten exactly what we wanted: every way to connect to a host named ftp.kernel.org through a TCP connection to its FTP port.","translation":"మనం కోరుకున్నది ఖచ్చితంగా పొందాము: ftp.kernel.org అనే హోస్ట్‌కి దాని FTP పోర్ట్‌కి TCP కనెక్షన్ ద్వారా కనెక్ట్ అవ్వడానికి ప్రతి మార్గం.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Note that several IP addresses were returned because this service, to spread load, is located at several different machines on the Internet.","translation":"లోడ్‌ను విస్తరించడానికి, ఈ సేవ ఇంటర్నెట్‌లో అనేక విభిన్న మెషీన్‌లలో ఉన్నందున, అనేక IP చిరునామాలు తిరిగి ఇవ్వబడ్డాయి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"You should generally always use the first address returned, and if a connection fails, then try the remaining ones, because there is intelligence built into the name-resolution system to properly randomize the order in which you receive them.","translation":"మీరు సాధారణంగా ఎల్లప్పుడూ తిరిగి వచ్చిన మొదటి చిరునామాను ఉపయోగించాలి మరియు కనెక్షన్ విఫలమైతే, మిగిలిన వాటిని ప్రయత్నించండి, ఎందుకంటే మీరు వాటిని స్వీకరించే క్రమాన్ని సరిగ్గా యాదృచ్ఛికంగా చేయడానికి పేరు-రిజల్యూషన్ సిస్టమ్‌లో తెలివితేటలు నిర్మించబడ్డాయి.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Here is another query, which describes how I can connect from my laptop to the HTTP interface of the IANA that assigns port numbers in the first place:","translation":"మొదట పోర్ట్ నంబర్‌లను కేటాయించే IANA యొక్క HTTP ఇంటర్‌ఫేస్‌కి నా ల్యాప్‌టాప్ నుండి నేను ఎలా కనెక్ట్ అవ్వగలనో వివరించే మరొక ప్రశ్న ఇక్కడ ఉంది:","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The IANA web site is actually a good one for demonstrating the utility of the AI_ADDRCONFIG flag, because—like any other good Internet standards organization—their web site already supports IPv6.","translation":"IANA వెబ్‌సైట్ వాస్తవానికి AI_ADDRCONFIG ఫ్లాగ్ యొక్క యుటిలిటీని ప్రదర్శించడానికి మంచిది, ఎందుకంటే—మరేదైనా మంచి ఇంటర్నెట్ ప్రమాణాల సంస్థలాగే—వారి వెబ్‌సైట్ ఇప్పటికే IPv6కి మద్దతు ఇస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"This can be useful if you are not going to try to use the addresses yourself, but if you are providing some sort of directory information to other hosts or programs.","translation":"మీరు చిరునామాలను ఉపయోగించడానికి ప్రయత్నించకపోతే ఇది ఉపయోగకరంగా ఉంటుంది, కానీ మీరు ఇతర హోస్ట్‌లు లేదా ప్రోగ్రామ్‌లకు ఏదైనా డైరెక్టరీ సమాచారాన్ని అందిస్తుంటే.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"One last circumstance that you will commonly encounter is where you either are making a new connection, or maybe have just received a connection to one of your own sockets, and you want an attractive hostname to display to the user or record in a log file.","translation":"మీరు సాధారణంగా ఎదుర్కొనే చివరి పరిస్థితి ఏమిటంటే, మీరు కొత్త కనెక్షన్‌ను ఏర్పరుస్తున్నప్పుడు లేదా మీ స్వంత సాకెట్‌లలో ఒకదానికి కనెక్షన్‌ను స్వీకరించినప్పుడు, మీరు వినియోగదారుకు ప్రదర్శించడానికి లేదా లాగ్ ఫైల్‌లో రికార్డ్ చేయడానికి ఆకర్షణీయమైన హోస్ట్ పేరును కోరుకుంటారు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"This is slightly dangerous because a hostname lookup can take quite a bit of time, even on the modern Internet, and might return a hostname that no longer works by the time you go and check your logs—so for log files, try to record both the hostname and raw IP address!","translation":"హోస్ట్ పేరును చూడటానికి చాలా సమయం పట్టవచ్చు కాబట్టి ఇది కొంచెం ప్రమాదకరమైనది, ఆధునిక ఇంటర్నెట్‌లో కూడా, మరియు మీరు మీ లాగ్‌లను తనిఖీ చేయడానికి వెళ్ళే సమయానికి ఇక పని చేయని హోస్ట్ పేరును తిరిగి ఇవ్వవచ్చు—కాబట్టి లాగ్ ఫైల్‌ల కోసం, హోస్ట్ పేరు మరియు ముడి IP చిరునామా రెండింటినీ రికార్డ్ చేయడానికి ప్రయత్నించండి!","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"You can also supply getaddrinfo() with the attributes of a socket that is already connected to a remote peer, and get a canonical name in return:","translation":"మీరు ఇప్పటికే రిమోట్ పీర్‌కి కనెక్ట్ చేయబడిన సాకెట్ యొక్క లక్షణాలతో getaddrinfo()ని కూడా అందించవచ్చు మరియు బదులుగా ప్రామాణిక పేరును పొందవచ్చు:","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Again, this will work only if the owner of the IP address happens to have a name defined for it (and, obviously, it requires the hostname lookup to succeed).","translation":"మళ్ళీ, IP చిరునామా యజమానికి దాని కోసం పేరు నిర్వచించబడితే మాత్రమే ఇది పని చేస్తుంది (మరియు, స్పష్టంగా, ఇది హోస్ట్ పేరును చూడటం విజయవంతం కావాలి).","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The flags available vary somewhat by operating system, and you should always consult your own computer's documentation (not to mention its configuration!) if you are confused about a value that it chooses to return.","translation":"అందుబాటులో ఉన్న ఫ్లాగ్‌లు ఆపరేటింగ్ సిస్టమ్‌ను బట్టి కొంతవరకు మారుతూ ఉంటాయి మరియు అది తిరిగి ఇవ్వడానికి ఎంచుకున్న విలువ గురించి మీకు అయోమయంగా ఉంటే మీరు ఎల్లప్పుడూ మీ స్వంత కంప్యూటర్ డాక్యుమెంటేషన్‌ను సంప్రదించాలి (దాని కాన్ఫిగరేషన్‌ను చెప్పనవసరం లేదు!).","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"AI_ALL: We have already discussed that the AI_V4MAPPED option will save you in the situation where you are on a purely IPv6-connected host, but the host to which you want to connect advertises only IPv4 addresses: it resolves this problem by “mapping” the IPv4 addresses to their IPv6 equivalent.","translation":"AI_ALL: మీరు పూర్తిగా IPv6-కనెక్ట్ చేయబడిన హోస్ట్‌లో ఉన్న పరిస్థితిలో AI_V4MAPPED ఎంపిక మిమ్మల్ని ఎలా కాపాడుతుందో మేము ఇప్పటికే చర్చించాము, అయితే మీరు కనెక్ట్ అవ్వాలనుకుంటున్న హోస్ట్ IPv4 చిరునామాలను మాత్రమే ప్రకటిస్తుంది: ఇది IPv4 చిరునామాలను వాటి IPv6 సమానానికి “మ్యాపింగ్” చేయడం ద్వారా ఈ సమస్యను పరిష్కరిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"AI_NUMERICHOST: This turns off any attempt to interpret the hostname parameter (the first parameter to getaddrinfo()) as a textual hostname like cern.ch, and only tries to interpret the hostname string as a literal IPv4 or IPv6 hostname like 74.207.234.78 or fe80::fcfd:4aff:fecf:ea4e.","translation":"AI_NUMERICHOST: ఇది హోస్ట్ పేరు పరామితిని (getaddrinfo()కి మొదటి పరామితి) cern.ch వంటి టెక్స్ట్‌తో కూడిన హోస్ట్ పేరుగా అర్థం చేసుకోవడానికి చేసే ప్రయత్నాన్ని ఆపివేస్తుంది మరియు హోస్ట్ పేరు స్ట్రింగ్‌ను 74.207.234.78 లేదా fe80::fcfd:4aff:fecf:ea4e వంటి అక్షర IPv4 లేదా IPv6 హోస్ట్ పేరుగా అర్థం చేసుకోవడానికి మాత్రమే ప్రయత్నిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"AI_NUMERICSERV: This turns off symbolic port names like www and insists that port numbers like 80 be used instead.","translation":"AI_NUMERICSERV: ఇది www వంటి సాంకేతిక పోర్ట్ పేర్లను ఆపివేస్తుంది మరియు బదులుగా 80 వంటి పోర్ట్ నంబర్‌లను ఉపయోగించాలని పట్టుబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Each hex digit corresponds to four bits, so each pair of hex digits represents a byte of data.","translation":"ప్రతి హెక్స్ అంకె నాలుగు బిట్‌లకు అనుగుణంగా ఉంటుంది, కాబట్టి ప్రతి హెక్స్ అంకెల జత డేటా యొక్క ఒక బైట్‌ను సూచిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Some computers are “big-endian” and put the most significant byte first, just like we do when writing decimal digits; others are “little-endian” and put the least significant byte first.","translation":"కొన్ని కంప్యూటర్లు “బిగ్-ఎండియన్” మరియు అత్యంత ముఖ్యమైన బైట్‌ను మొదట ఉంచుతాయి, మనం దశాంశ అంకెలను రాసినప్పుడు చేసినట్లుగానే; మరికొన్ని “లిటిల్-ఎండియన్” మరియు అతి తక్కువ ముఖ్యమైన బైట్‌ను మొదట ఉంచుతాయి.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Python makes it very easy to see the difference between the two endiannesses.","translation":"రెండు ఎండియన్‌ల మధ్య వ్యత్యాసాన్ని చూడటం పైథాన్‌తో చాలా సులభం.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Simply use the struct module, which provides a variety of operations for converting data to and from popular binary formats.","translation":"డేటాను ప్రముఖ బైనరీ ఫార్మాట్‌లకు మరియు వాటి నుండి మార్చడానికి అనేక కార్యకలాపాలను అందించే struct మాడ్యూల్‌ను ఉపయోగించండి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Here is the number 4253 represented first in a little-endian format and then in a big-endian order:","translation":"ఇక్కడ 4253 సంఖ్య మొదట లిటిల్-ఎండియన్ ఆకృతిలో మరియు తరువాత బిగ్-ఎండియన్ క్రమంలో సూచించబడింది:","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"You can think of the struct codes for these two orders as little arrows pointing toward the least significant end of a string of bytes.","translation":"ఈ రెండు ఆర్డర్‌ల కోసం struct కోడ్‌లను మీరు చిన్న బాణాలుగా భావించవచ్చు, ఇవి బైట్‌ల స్ట్రింగ్ యొక్క అతి తక్కువ ముఖ్యమైన ముగింపు వైపు చూపిస్తాయి.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Select network byte order with the '!' prefix if the data form at is up to you.","translation":"డేటా ఫార్మాట్ మీ ఇష్టం అయితే '!' ఉపసర్గతో నెట్‌వర్క్ బైట్ ఆర్డర్‌ను ఎంచుకోండి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"If someone else has designed the protocol and specified little-endian, then you will have to use '<' instead.","translation":"మరొకరు ప్రోటోకాల్‌ను రూపొందించి, లిటిల్-ఎండియన్‌ను పేర్కొంటే, మీరు '<' ని ఉపయోగించాలి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Always test struct to see how it lays out your data compared to the specification for the protocol you are speaking.","translation":"మీరు మాట్లాడుతున్న ప్రోటోకాల్ కోసం స్పెసిఫికేషన్‌తో పోలిస్తే మీ డేటాను అది ఎలా ఉంచుతుందో చూడటానికి ఎల్లప్పుడూ struct ని పరీక్షించండి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"I suggest that you ignore these awkward functions, and use the struct module instead; it is more flexible, more general, and produces more readable code.","translation":"ఈ ఇబ్బందికరమైన ఫంక్షన్లను విస్మరించమని నేను సూచిస్తున్నాను మరియు బదులుగా struct మాడ్యూల్‌ను ఉపయోగించండి; ఇది మరింత సౌకర్యవంతంగా, మరింత సాధారణంగా ఉంటుంది మరియు మరింత చదవగలిగే కోడ్‌ను ఉత్పత్తి చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"If you are using UDP datagrams for communication, then the protocol itself takes the trouble to deliver your data in discrete and identifiable chunks.","translation":"మీరు కమ్యూనికేషన్ కోసం UDP డేటాగ్రామ్‌లను ఉపయోగిస్తుంటే, ప్రోటోకాల్ మీ డేటాను ప్రత్యేకమైన మరియు గుర్తించదగిన ముక్కలుగా అందించడానికి శ్రద్ధ తీసుకుంటుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"But if you have made the far more common option of using a TCP stream for communication, then you will face the issue of framing.","translation":"కానీ మీరు కమ్యూనికేషన్ కోసం TCP స్ట్రీమ్‌ను ఉపయోగించడం యొక్క సాధారణ ఎంపికను ఎంచుకుంటే, మీరు ఫ్రేమింగ్ సమస్యను ఎదుర్కొంటారు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Since the data you supply to sendall() might be broken up into several packets, the program that receives your message might have to make several recv() calls before your whole message has been read.","translation":"మీరు sendall()కి అందించే డేటా అనేక ప్యాకెట్‌లుగా విభజించబడవచ్చు కాబట్టి, మీ సందేశాన్ని స్వీకరించే ప్రోగ్రామ్ మీ మొత్తం సందేశం చదవడానికి ముందు అనేక recv() కాల్‌లు చేయవలసి ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"The issue of framing asks the question: when is it safe for the receiver to finally stop calling recv() and respond to your message?","translation":"ఫ్రేమింగ్ సమస్య ఈ ప్రశ్నను లేవనెత్తుతుంది: రిసీవర్ చివరకు recv()ని కాల్ చేయడం ఆపి, మీ సందేశానికి ప్రతిస్పందించడం ఎప్పుడు సురక్షితం?","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"First, there is a pattern that can be used by extremely simple network protocols that involve only the delivery of data.","translation":"ముందుగా, డేటాను అందించడం మాత్రమే కలిగి ఉన్న అత్యంత సాధారణ నెట్‌వర్క్ ప్రోటోకాల్‌ల ద్వారా ఉపయోగించగల నమూనా ఉంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"In this case, the sender can loop until all of the outgoing data has been passed to sendall() and then close() the socket.","translation":"ఈ సందర్భంలో, పంపేవారు మొత్తం అవుట్‌గోయింగ్ డేటా sendall()కి పంపబడే వరకు లూప్ చేయవచ్చు మరియు తరువాత సాకెట్‌ను close() చేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The receiver need only call recv() repeatedly until the call finally returns an empty string, indicating that the sender has finally closed the socket.","translation":"పంపేవారు చివరకు సాకెట్‌ను మూసివేశారని సూచిస్తూ, కాల్ చివరకు ఖాళీ స్ట్రింగ్‌ను తిరిగి ఇచ్చే వరకు రిసీవర్ పదేపదే recv()ని మాత్రమే కాల్ చేయాలి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Note the nicety that, since this socket is not intended to receive any data, the client and server both go ahead and shut down communication in the other direction.","translation":"ఈ సాకెట్ ఎలాంటి డేటాను స్వీకరించడానికి ఉద్దేశించబడనందున, క్లయింట్ మరియు సర్వర్ రెండూ ఇతర దిశలో కమ్యూనికేషన్‌ను మూసివేస్తాయని గమనించండి.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"A second pattern is a variant on the first: streaming in both directions.","translation":"రెండవ నమూనా మొదటి దాని యొక్క ఒక వైవిధ్యం: రెండు దిశలలో స్ట్రీమింగ్.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"A third pattern, which we have already seen, is to use fixed-length messages.","translation":"మనం ఇప్పటికే చూసిన మూడవ నమూనా, స్థిర-పొడవు సందేశాలను ఉపయోగించడం.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Imagine that these 28 bytes arrive at their destination in 8-byte packets.","translation":"ఈ 28 బైట్‌లు 8-బైట్ ప్యాకెట్‌లలో గమ్యస్థానానికి చేరుకుంటాయని ఊహించండి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"After processing the first packet, we will find the decompression object's unused_data slot still empty.","translation":"మొదటి ప్యాకెట్‌ను ప్రాసెస్ చేసిన తర్వాత, డీకంప్రెషన్ ఆబ్జెక్ట్ యొక్క unused_data స్లాట్ ఇంకా ఖాళీగా ఉందని మేము కనుగొంటాము.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"If another stream of compressed data is coming, then we have to provide everything past the '.'","translation":"మరొక కంప్రెస్ చేయబడిన డేటా స్ట్రీమ్ వస్తుంటే, మనం '.' తర్వాత ఉన్న ప్రతిదాన్ని అందించాలి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Again, most protocol designers make compression optional and simply do their own framing.","translation":"మళ్ళీ, చాలా ప్రోటోకాల్ డిజైనర్లు కంప్రెషన్‌ను ఐచ్ఛికంగా చేస్తారు మరియు వారి స్వంత ఫ్రేమింగ్‌ను చేస్తారు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"So when we illustrated socket timeouts in Listing 2-2, we were careful to catch the exception socket.timeout.","translation":"కాబట్టి మేము జాబితా 2-2లో సాకెట్ టైమ్‌అవుట్‌లను వివరించినప్పుడు, మేము socket.timeout మినహాయింపును జాగ్రత్తగా పట్టుకున్నాము.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"This exception is raised when getaddrinfo() cannot find a name or service that you ask about.","translation":"మీరు అడిగిన పేరు లేదా సేవను getaddrinfo() కనుగొనలేనప్పుడు ఈ మినహాయింపు ఏర్పడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"This is the workhorse of the socket module, and will be raised for nearly every failure that can happen at any stage in a network transmission.","translation":"ఇది సాకెట్ మాడ్యూల్ యొక్క వర్క్‌హార్స్, మరియు నెట్‌వర్క్ ప్రసారంలో ఏ దశలోనైనా జరిగే దాదాపు ప్రతి వైఫల్యానికి ఇది ఏర్పడుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"This exception is raised only if you, or a library that you are using, decides to set a timeout on a socket.","translation":"మీరు లేదా మీరు ఉపయోగిస్తున్న లైబ్రరీ సాకెట్‌పై టైమ్‌అవుట్‌ను సెట్ చేయాలని నిర్ణయించుకుంటే మాత్రమే ఈ మినహాయింపు ఏర్పడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"A big question when you are using higher-level socket-based protocols from Python is whether they allow raw socket errors to hit your own code.","translation":"మీరు పైథాన్ నుండి అధిక-స్థాయి సాకెట్-ఆధారిత ప్రోటోకాల్‌లను ఉపయోగిస్తున్నప్పుడు ఒక పెద్ద ప్రశ్న ఏమిటంటే, అవి మీ స్వంత కోడ్‌ను తాకడానికి ముడి సాకెట్ లోపాలను అనుమతిస్తాయా లేదా.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Consult documentation carefully if you are in doubt about the approach taken by a particular library.","translation":"ఒక నిర్దిష్ట లైబ్రరీ తీసుకున్న విధానం గురించి మీకు సందేహం ఉంటే, డాక్యుమెంటేషన్‌ను జాగ్రత్తగా సంప్రదించండి.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"For the major packages that we cover in the subsequent chapters of this book, I have tried to provide insets that list the possible exceptions.","translation":"ఈ పుస్తకం యొక్క తదుపరి అధ్యాయాలలో మేము కవర్ చేసే ప్రధాన ప్యాకేజీల కోసం, సాధ్యమయ్యే మినహాయింపులను జాబితా చేసే ఇన్‌సెట్‌లను అందించడానికి నేను ప్రయత్నించాను.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"When writing a network program, how should you handle all of the errors that can occur?","translation":"నెట్‌వర్క్ ప్రోగ్రామ్‌ను వ్రాసేటప్పుడు, మీరు సంభవించే అన్ని లోపాలను ఎలా నిర్వహించాలి?","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"The first is not to handle exceptions at all.","translation":"మొదటిది ఏమిటంటే మినహాయింపులను అస్సలు నిర్వహించకూడదు.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"If you are writing a library of calls to be used by other programmers, then this first approach is usually preferable.","translation":"మీరు ఇతర ప్రోగ్రామర్‌లు ఉపయోగించాల్సిన కాల్‌ల లైబ్రరీని వ్రాస్తుంటే, అప్పుడు ఈ మొదటి విధానం సాధారణంగా ఉత్తమం.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"But if you are indeed writing a library, then there is a second approach to consider: wrapping the network errors in an exception of your own.","translation":"కానీ మీరు నిజంగా ఒక లైబ్రరీని వ్రాస్తుంటే, పరిగణించవలసిన రెండవ విధానం ఉంది: నెట్‌వర్క్ లోపాలను మీ స్వంత మినహాయింపులో చుట్టడం.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"If you offer a netcopy() method that copies a file from one remote machine to another, for example, a socket.error does not help the caller know whether the error was with the connection to the source machine.","translation":"మీరు ఒక ఫైల్‌ను ఒక రిమోట్ మెషిన్ నుండి మరొకదానికి కాపీ చేసే netcopy() పద్ధతిని అందిస్తే, ఉదాహరణకు, సోర్స్ మెషిన్‌కు కనెక్షన్‌తో లోపం ఉందో లేదో తెలుసుకోవడానికి socket.error సహాయపడదు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"A third approach to exceptions is to wrap a try...except clause around every single network call that you ever make, and print out a pithy error message in its place.","translation":"మినహాయింపులకు మూడవ విధానం ఏమిటంటే, మీరు ఎప్పుడైనా చేసే ప్రతి నెట్‌వర్క్ కాల్ చుట్టూ try...except నిబంధనను చుట్టడం మరియు దాని స్థానంలో ఒక పిత్తి లోపం సందేశాన్ని ముద్రించడం.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"And the idea of having big exception handlers that cover lots of code is the fourth and—in my opinion—best approach.","translation":"మరియు చాలా కోడ్‌ను కవర్ చేసే పెద్ద మినహాయింపు హ్యాండ్లర్‌లను కలిగి ఉండాలనే ఆలోచన నాల్గవది మరియు - నా అభిప్రాయం ప్రకారం - ఉత్తమ విధానం.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"In long-running programs, this is common.","translation":"దీర్ఘకాలికంగా నడుస్తున్న ప్రోగ్రామ్‌లలో, ఇది సాధారణం.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"For text, the big question will be choosing an encoding, so that the symbols you want to transmit can be changed into bytes.","translation":"వచనానికి, మీరు ప్రసారం చేయాలనుకుంటున్న చిహ్నాలను బైట్‌లుగా మార్చడానికి ఎన్‌కోడింగ్‌ను ఎంచుకోవడం పెద్ద ప్రశ్న అవుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"When you can ping another machine and get an answer in around 1.2 ms, you are on a pretty fast network.","translation":"మీరు మరొక యంత్రానికి పింగ్ చేసి, దాదాపు 1.2 msలో సమాధానం పొందగలిగితే, మీరు చాలా వేగవంతమైన నెట్‌వర్క్‌లో ఉన్నారు.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"But the cost of the round-trip means that, if the server simply answers one question after another, then it can answer at most around 1,000 requests per second.","translation":"కానీ రౌండ్-ట్రిప్ ఖర్చు అంటే, సర్వర్ ఒకదాని తర్వాత ఒకటి ప్రశ్నలకు సమాధానం ఇస్తే, అది సెకనుకు 1,000 అభ్యర్థనలకు మించి సమాధానం ఇవ్వలేదు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"So the client and server both spend most of their time waiting.","translation":"అందువల్ల, క్లయింట్ మరియు సర్వర్ రెండూ తమ సమయాన్ని ఎక్కువగా ఎదురుచూస్తూ గడుపుతాయి.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"A third observation is that the operating system is really very aggressive in taking tasks upon itself and letting the programs go ahead and get on with their lives.","translation":"మూడవ పరిశీలన ఏమిటంటే, ఆపరేటింగ్ సిస్టమ్ నిజంగా చాలా దూకుడుగా పనులను తీసుకుంటుంది మరియు ప్రోగ్రామ్‌లను ముందుకు సాగనిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Look, for example, at how each sendall() call uses only a few dozen microseconds to queue up the data for transmission, and then lets the program proceed to its next instruction.","translation":"ఉదాహరణకు, ప్రతి sendall() కాల్ ప్రసారం కోసం డేటాను క్యూ చేయడానికి కొన్ని డజన్ల మైక్రో సెకన్లను మాత్రమే ఉపయోగిస్తుంది మరియు ప్రోగ్రామ్‌ను దాని తదుపరి సూచనకు వెళ్ళడానికి అనుమతిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The operating system takes care of getting the data actually sent, without making the program wait.","translation":"ప్రోగ్రామ్‌ను వేచి ఉండకుండానే డేటాను పంపించే బాధ్యతను ఆపరేటింగ్ సిస్టమ్ చూసుకుంటుంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Finally, note the wide gulfs of time that are involved in simply setting up and tearing down the socket.","translation":"చివరగా, సాకెట్‌ను సెటప్ చేయడం మరియు కూల్చివేయడంలో పాల్గొన్న విస్తారమైన సమయాన్ని గమనించండి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"This leads to designers adding protocol features like the keep-alive mechanism of the HTTP/1.1 protocol.","translation":"ఇది డిజైనర్లు HTTP/1.1 ప్రోటోకాల్ యొక్క కీప్-అలైవ్ మెకానిజం వంటి ప్రోటోకాల్ లక్షణాలను జోడించడానికి దారి తీస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"So if we talk to only one client at a time and patiently wait on the network to send and receive each request, then we can expect our servers to run hundreds or thousands of times more slowly.","translation":"కాబట్టి, మేము ఒక సమయంలో ఒక క్లయింట్‌తో మాత్రమే మాట్లాడి, ప్రతి అభ్యర్థనను పంపడానికి మరియు స్వీకరించడానికి నెట్‌వర్క్‌లో ఓపికగా వేచి ఉంటే, మా సర్వర్‌లు వందల లేదా వేల రెట్లు నెమ్మదిగా నడుస్తాయని మేము ఆశించవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Recall that a modern processor can often execute more than 2,000 machine-level instructions per microsecond.","translation":"ఒక ఆధునిక ప్రాసెసర్ తరచుగా సెకనుకు 2,000 కంటే ఎక్కువ మెషిన్-స్థాయి సూచనలను అమలు చేస్తుందని గుర్తుంచుకోండి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"That means that the 500 μs delay we discussed earlier leaves the server idle for nearly a half-million clock cycles before letting it continue work!","translation":"అంటే మనం ఇంతకు ముందు చర్చించిన 500 μs ఆలస్యం సర్వర్ పనిని కొనసాగించడానికి ముందు దాదాపు అర్ధ మిలియన్ క్లాక్ చక్రాల వరకు నిష్క్రియంగా ఉంచుతుంది!","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Through the rest of this chapter, we will look at better ways to construct servers in view of these limitations.","translation":"ఈ అధ్యాయం అంతటా, ఈ పరిమితుల దృష్ట్యా సర్వర్‌లను నిర్మించడానికి మంచి మార్గాలను మేము పరిశీలిస్తాము.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Running a Benchmark Having used microsecond tracing to dissect a simple client and server, we are going to need a better system for comparing the subsequent server designs that we explore.","translation":"ఒక సాధారణ క్లయింట్ మరియు సర్వర్‌ను విశ్లేషించడానికి మైక్రో సెకండ్ ట్రేసింగ్‌ను ఉపయోగించిన తర్వాత, మేము అన్వేషించే తదుపరి సర్వర్ డిజైన్‌లను సరిపోల్చడానికి ఒక మంచి వ్యవస్థను పొందాలి.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Not only do we lack the space to print and analyze increasingly dense and convoluted timestamp traces, but that approach would make it very difficult to step back and to ask, “Which of these server designs is working the best?”","translation":"పెరుగుతున్న దట్టమైన మరియు గందరగోళ సమయ ముద్రణ జాడలను ముద్రించడానికి మరియు విశ్లేషించడానికి మాకు స్థలం లేదు, కానీ ఆ విధానం వెనుకకు వెళ్లి, “ఈ సర్వర్ డిజైన్‌లలో ఏది ఉత్తమంగా పనిచేస్తుంది?” అని అడగడం చాలా కష్టతరం చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"We are therefore going to turn now to a public tool: the FunkLoad tool, written in Python and available from the Python Package Index.","translation":"అందువల్ల, మేము ఇప్పుడు ఒక పబ్లిక్ సాధనం వైపు తిరగబోతున్నాము: ఫంక్‌లోడ్ సాధనం, ఇది పైథాన్‌లో వ్రాయబడింది మరియు పైథాన్ ప్యాకేజీ ఇండెక్స్ నుండి అందుబాటులో ఉంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"You can install it in a virtual environment with a simple command: $ pip install funkload","translation":"మీరు దీన్ని ఒక సాధారణ కమాండ్‌తో వర్చువల్ వాతావరణంలో ఇన్‌స్టాల్ చేయవచ్చు: $ pip install funkload","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"There are other popular benchmark tools available on the Web, including the “Apache bench” program named ab, but for this book it seemed that the leading Python load tester would be a good choice.","translation":"వెబ్‌లో “అపాచీ బెంచ్” ప్రోగ్రామ్ abతో సహా ఇతర ప్రసిద్ధ బెంచ్‌మార్క్ సాధనాలు అందుబాటులో ఉన్నాయి, అయితే ఈ పుస్తకం కోసం ప్రముఖ పైథాన్ లోడ్ టెస్టర్ మంచి ఎంపిక అనిపించింది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"FunkLoad can take a test routine and run more and more copies of it simultaneously to test how the resources it needs struggle with the rising load.","translation":"ఫంక్‌లోడ్ ఒక పరీక్షా రొటీన్‌ను తీసుకోవచ్చు మరియు పెరుగుతున్న లోడ్‌తో దానికి అవసరమైన వనరులు ఎలా పోరాడుతున్నాయో పరీక్షించడానికి ఒకేసారి ఎక్కువ కాపీలను అమలు చేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Our test routine will be an expanded version of the simple client that we used earlier: it will ask ten questions of the server instead of three, so that the network conversation itself will take up more time relative to the TCP setup and teardown times that come at the beginning and end.","translation":"మా పరీక్షా రొటీన్ మనం ఇంతకు ముందు ఉపయోగించిన సాధారణ క్లయింట్ యొక్క విస్తరించిన వెర్షన్: ఇది మూడు ప్రశ్నలకు బదులుగా సర్వర్‌ను పది ప్రశ్నలు అడుగుతుంది, తద్వారా నెట్‌వర్క్ సంభాషణే ప్రారంభంలో మరియు ముగింపులో వచ్చే TCP సెటప్ మరియు కూల్చివేసే సమయానికి సంబంధించి ఎక్కువ సమయం తీసుకుంటుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"The performance of our simple server Since we are sending ten Launcelot questions per test trial, the 325 test-per-second maximum that the simple server reaches represents 3,250 questions and answers—more than the 1,000 per second that we guessed were possible when testing server_simple.py over the slower SSH tunnel, but still of the same order of magnitude.","translation":"మా సాధారణ సర్వర్ పనితీరు మేము పరీక్షా విచారణకు పది లాన్సెలట్ ప్రశ్నలను పంపుతున్నందున, సాధారణ సర్వర్ చేరుకునే సెకనుకు 325 పరీక్షలు 3,250 ప్రశ్నలు మరియు సమాధానాలను సూచిస్తాయి—నెమ్మదిగా SSH టన్నెల్ ద్వారా server_simple.pyని పరీక్షిస్తున్నప్పుడు మేము ఊహించిన సెకనుకు 1,000 కంటే ఎక్కువ, కానీ ఇప్పటికీ అదే పరిమాణంలో ఉంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"For example, the OpenSSL web site does (as we would expect!): $ python sslclient.py www.openssl.org","translation":"ఉదాహరణకు, OpenSSL వెబ్‌సైట్ చేస్తుంది (మనం ఊహించినట్లుగానే!): $ python sslclient.py www.openssl.org","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"The document https://www.openssl.org/ is 15941 bytes long","translation":"https://www.openssl.org/ పత్రం 15941 బైట్‌ల పొడవు ఉంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"The Linksys router here at my house, by contrast, uses a self-signed certificate that can provide encryption but fails to provide a signature that can be verified against any of the famous CAs in the certfiles.crt file.","translation":"నా ఇంటి దగ్గర ఉన్న Linksys రౌటర్, దీనికి భిన్నంగా, ఎన్‌క్రిప్షన్ అందించగల స్వంత సంతకం చేసిన సర్టిఫికేట్‌ను ఉపయోగిస్తుంది, కానీ certfiles.crt ఫైల్‌లోని ప్రసిద్ధ CA లలో దేనితోనూ ధృవీకరించబడే సంతకాన్ని అందించడంలో విఫలమవుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"So, with the conservative settings in our sslclient.py program, the connection fails: $ python sslclient.py ten22.rhodesmill.org","translation":"కాబట్టి, మా sslclient.py ప్రోగ్రామ్‌లోని సంప్రదాయ సెట్టింగ్‌లతో, కనెక్షన్ విఫలమవుతుంది: $ python sslclient.py ten22.rhodesmill.org","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Interestingly, Google (as of this writing) provides a single www.google.com certificate not only for that specific domain name, but also for its google.com address since all that is hosted there is a redirect to the www name:","translation":"ఆసక్తికరంగా, Google (ఈ సమయంలో) ఆ నిర్దిష్ట డొమైన్ పేరు కోసం మాత్రమే కాకుండా, దాని google.com చిరునామా కోసం కూడా ఒకే www.google.com సర్టిఫికేట్‌ను అందిస్తుంది, ఎందుకంటే అక్కడ హోస్ట్ చేయబడినదంతా www పేరుకు మళ్ళించబడుతుంది:","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"$ python sslclient.py google.com","translation":"$ python sslclient.py google.com","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Writing an SSL server looks much the same: code like that in Listing 3-1 is supplemented so that the client socket returned by each accept() call gets immediately wrapped with wrap_socket(), but with different options than are used with a client.","translation":"SSL సర్వర్‌ను రాయడం దాదాపు ఒకేలా ఉంటుంది: జాబితా 3-1 లోని కోడ్ అనుబంధించబడింది, తద్వారా ప్రతి accept() కాల్ ద్వారా తిరిగి వచ్చే క్లయింట్ సాకెట్ వెంటనే wrap_socket()తో చుట్టబడుతుంది, అయితే క్లయింట్ ఉపయోగించే వాటి కంటే భిన్నమైన ఎంపికలతో.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"In general, here are the three most popular ways of using wrap_socket() (see the ssl Standard Library documentation to learn about all of the rest of its options):","translation":"సాధారణంగా, wrap_socket()ని ఉపయోగించడానికి మూడు అత్యంత ప్రజాదరణ పొందిన మార్గాలు ఇక్కడ ఉన్నాయి (మిగిలిన అన్ని ఎంపికల గురించి తెలుసుకోవడానికి ssl స్టాండర్డ్ లైబ్రరీ డాక్యుమెంటేషన్‌ను చూడండి):","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The first form is the one shown in Listing 6–1, and is the most common form of the call seen in clients: wrap_socket(sock, ssl_version=ssl. PROTOCOL_SSLv3, » cert_reqs=ssl. CERT_REQUIRED, ca_certs=ca_certs_path)","translation":"మొదటి రూపం జాబితా 6–1లో చూపబడింది మరియు ఇది క్లయింట్‌లలో కనిపించే కాల్ యొక్క అత్యంత సాధారణ రూపం: wrap_socket(sock, ssl_version=ssl. PROTOCOL_SSLv3, » cert_reqs=ssl. CERT_REQUIRED, ca_certs=ca_certs_path)","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Here the client asserts no particular identity—at least, TLS provides no way for the server to know who is connecting.","translation":"ఇక్కడ క్లయింట్ నిర్దిష్ట గుర్తింపును పేర్కొనలేదు— కనీసం, ఎవరు కనెక్ట్ అవుతున్నారో తెలుసుకోవడానికి TLS సర్వర్‌కు మార్గం లేదు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Servers generally do not care whether clients connect with certificates, so the wrap_socket() calls that they make after an accept() use a different set of named parameters that provide the documents that establish their own identity.","translation":"సాధారణంగా సర్వర్లు క్లయింట్‌లు సర్టిఫికెట్‌లతో కనెక్ట్ అవుతున్నాయా లేదా అనే దాని గురించి పట్టించుకోవు, కాబట్టి వారు accept() తర్వాత చేసే wrap_socket() కాల్‌లు వారి స్వంత గుర్తింపును ఏర్పాటు చేసే పత్రాలను అందించే వేరే పేరున్న పరామితుల సమితిని ఉపయోగిస్తాయి.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Finally, there do exist situations where you want to run a server that checks the certificates of the clients that are connecting.","translation":"చివరగా, మీరు కనెక్ట్ అవుతున్న క్లయింట్‌ల సర్టిఫికెట్‌లను తనిఖీ చేసే సర్వర్‌ను అమలు చేయాలనుకునే పరిస్థితులు ఉన్నాయి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"This can be useful if the protocol that you are wrapping provides weak or even non-existent authentication, and the TLS layer will be providing the only assurance about who is connecting.","translation":"మీరు చుట్టుముట్టే ప్రోటోకాల్ బలహీనమైన లేదా అస్తిత్వం లేని ప్రమాణీకరణను అందిస్తే ఇది ఉపయోగకరంగా ఉంటుంది మరియు ఎవరు కనెక్ట్ అవుతున్నారనే దాని గురించి TLS లేయర్ మాత్రమే హామీని అందిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"You will use your CA to sign client certificates for each individual or machine that will be connecting, then have your server make a call like this: wrap_socket(sock, server_side=True, ssl_version=ssl. PROTOCOL_SSLv23, » cert_reqs=ssl. CERT_REQUIRED, ca_certs=ca_certs_path, » keyfile=\"mykeyfile\", certfile=\"mycertfile\")","translation":"మీరు కనెక్ట్ అయ్యే ప్రతి వ్యక్తి లేదా మెషిన్ కోసం క్లయింట్ సర్టిఫికెట్‌లపై సంతకం చేయడానికి మీ CAని ఉపయోగిస్తారు, ఆపై మీ సర్వర్ ఇలాంటి కాల్ చేయండి: wrap_socket(sock, server_side=True, ssl_version=ssl. PROTOCOL_SSLv23, » cert_reqs=ssl. CERT_REQUIRED, ca_certs=ca_certs_path, » keyfile=\"mykeyfile\", certfile=\"mycertfile\")","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Again, consult the ssl chapter in the Standard Library if you need to delve into the options more deeply; the documentation there has been getting quite a bit better, and might cover edge cases that we have not had room to discuss here in this chapter.","translation":"మళ్ళీ, మీరు ఎంపికలను మరింత లోతుగా పరిశోధించాలనుకుంటే, స్టాండర్డ్ లైబ్రరీలోని ssl అధ్యాయాన్ని సంప్రదించండి; అక్కడ ఉన్న డాక్యుమెంటేషన్ చాలా మెరుగ్గా ఉంది మరియు ఈ అధ్యాయంలో చర్చించడానికి మాకు స్థలం లేని అంచు కేసులను కవర్ చేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"If you are writing clients and servers that need to talk only to each other, try using PROTOCOL_TLSv1 as your protocol.","translation":"మీరు ఒకరితో ఒకరు మాత్రమే మాట్లాడవలసిన క్లయింట్‌లు మరియు సర్వర్‌లను వ్రాస్తుంటే, మీ ప్రోటోకాల్‌గా PROTOCOL_TLSv1ని ఉపయోగించడానికి ప్రయత్నించండి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"It is more modern and secure than any of the protocols that have SSL in their names.","translation":"ఇది SSLని కలిగి ఉన్న ప్రోటోకాల్‌ల కంటే ఆధునికమైనది మరియు సురక్షితమైనది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"The only reason to use SSL protocols—as shown in the foregoing example calls, and which are also currently CHAPTER 6 ■ TLS AND SSL 98 the defaults for the wrap_socket() call in the Standard Library—is if you need to speak to browsers or other third-party clients that might not have upgraded to full-fledged TLS yet.","translation":"SSL ప్రోటోకాల్‌లను ఉపయోగించడానికి ఏకైక కారణం—ముందు ఉదాహరణ కాల్‌లలో చూపిన విధంగా, మరియు ప్రస్తుతం చాప్టర్ 6 ■ TLS మరియు SSL 98 స్టాండర్డ్ లైబ్రరీలోని wrap_socket() కాల్ కోసం డిఫాల్ట్‌లు—మీరు బ్రౌజర్‌లతో లేదా పూర్తి స్థాయి TLSకి అప్‌గ్రేడ్ చేయని ఇతర మూడవ పక్ష క్లయింట్‌లతో మాట్లాడవలసి వస్తే.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Loose Ends When adding cryptography to your application, it is always a good idea to read up-to-date documentation.","translation":"మీ అప్లికేషన్‌కు క్రిప్టోగ్రఫీని జోడించేటప్పుడు, తాజాగా ఉన్న డాక్యుమెంటేషన్‌ను చదవడం ఎల్లప్పుడూ మంచిది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The advice given in this chapter would have been quite different if this revision of the book had happened even just one or two years earlier, and in two or three more years it will doubtless be out of date.","translation":"ఈ అధ్యాయంలో ఇచ్చిన సలహా, పుస్తకం యొక్క ఈ పునర్విమర్శ ఒకటి లేదా రెండు సంవత్సరాల ముందు జరిగి ఉంటే చాలా భిన్నంగా ఉండేది మరియు మరో రెండు లేదా మూడు సంవత్సరాలలో ఇది నిస్సందేహంగా కాలం చెల్లినది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Imagine that you run a typical web service consisting of front-end machines that serve HTML to customers and a back-end database that powers your service, and that all communication over your network is cleartext.","translation":"మీరు కస్టమర్‌లకు HTMLని అందించే ఫ్రంట్-ఎండ్ మెషీన్‌లతో కూడిన ఒక సాధారణ వెబ్ సేవను నడుపుతున్నారని ఊహించుకోండి మరియు మీ సేవను నడిపించే బ్యాక్-ఎండ్ డేటాబేస్ మరియు మీ నెట్‌వర్క్‌లో జరిగే అన్ని కమ్యూనికేషన్ స్పష్టంగా ఉన్నాయి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"This activity is called “network sniffing,” and is quite legitimate when performed by network administrators trying to fix problems on their own hardware.","translation":"ఈ కార్యాన్ని “నెట్‌వర్క్ స్నిఫింగ్” అని పిలుస్తారు మరియు నెట్‌వర్క్ నిర్వాహకులు వారి స్వంత హార్డ్‌వేర్‌పై సమస్యలను పరిష్కరించడానికి ప్రయత్నించినప్పుడు ఇది చాలా చట్టబద్ధమైనది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The traditional program tcpdump and the more sleek and modern wireshark are both good tools if you want to try observing some network packets yourself.","translation":"మీరు కొన్ని నెట్‌వర్క్ ప్యాకెట్‌లను మీరే గమనించడానికి ప్రయత్నించాలనుకుంటే, సాంప్రదాయ ప్రోగ్రామ్ tcpdump మరియు మరింత సొగసైన మరియు ఆధునిక వైర్‌షార్క్ రెండూ మంచి సాధనాలు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Perhaps the adversary is sitting in a coffee shop, and he has a wireless card that is collecting your traffic as you debug one of the servers, and he keeps it for later analysis.","translation":"బహుశా ప్రత్యర్థి ఒక కాఫీ షాప్‌లో కూర్చుని ఉండవచ్చు మరియు మీరు సర్వర్లలో ఒకదాన్ని డీబగ్ చేస్తున్నప్పుడు మీ ట్రాఫిక్‌ను సేకరించే వైర్‌లెస్ కార్డ్ అతని వద్ద ఉంది మరియు అతను దానిని తరువాత విశ్లేషణ కోసం ఉంచుకుంటాడు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"He will see any usernames and passwords that your clients use to connect to the servers behind them.","translation":"మీ క్లయింట్‌లు వాటి వెనుక ఉన్న సర్వర్‌లకు కనెక్ట్ అవ్వడానికి ఉపయోగించే ఏదైనా వినియోగదారు పేర్లు మరియు పాస్‌వర్డ్‌లను అతను చూస్తాడు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Log messages can also be intercepted, if they are being sent to a central location and happen to travel over a compromised IP segment or device.","translation":"లాగ్ సందేశాలను కూడా అడ్డుకోవచ్చు, అవి కేంద్ర స్థానానికి పంపబడితే మరియు రాజీపడిన IP విభాగం లేదా పరికరం ద్వారా ప్రయాణిస్తే.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"If your database server is not picky about who connects, aside from caring that the web front end sends a password, then the attacker can now launch a “replay attack,”","translation":"మీ డేటాబేస్ సర్వర్ ఎవరు కనెక్ట్ అవుతున్నారనే దాని గురించి పిరికివాడు కాకపోతే, వెబ్ ఫ్రంట్ ఎండ్ పాస్‌వర్డ్‌ను పంపుతుందనే దాని గురించి పట్టించుకోకుండా, అప్పుడు దాడి చేసే వ్యక్తి ఇప్పుడు “రీప్లే దాడి”ని ప్రారంభించవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"When your front ends ask for the hostname db.example.com, she could answer with the IP address of her own server, located anywhere in the world, instead.","translation":"మీ ఫ్రంట్ ఎండ్‌లు హోస్ట్‌నేమ్ db.example.com కోసం అడిగినప్పుడు, ఆమె ప్రపంచంలో ఎక్కడైనా ఉన్న తన స్వంత సర్వర్ యొక్క IP చిరునామాతో సమాధానం ఇవ్వవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"This is called a “man-in-the-middle” attack.","translation":"దీనిని “మధ్యలో ఉన్న వ్యక్తి” దాడి అంటారు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The secret to TLS is public-key cryptography, one of the great computing advances of the last few decades, and one of the very few areas of innovation in which academic computer science really shows its worth.","translation":"TLS రహస్యం పబ్లిక్-కీ క్రిప్టోగ్రఫీ, ఇది గత కొన్ని దశాబ్దాల గొప్ప కంప్యూటింగ్ పురోగతులలో ఒకటి మరియు అకాడెమిక్ కంప్యూటర్ సైన్స్ నిజంగా దాని విలువను చూపే కొన్ని ఆవిష్కరణలలో ఒకటి.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"If the public key is used to encrypt information, then the resulting block of binary data cannot be read by anyone, anywhere in the world, except by someone who holds the private key.","translation":"సమాచారాన్ని గుప్తీకరించడానికి పబ్లిక్ కీని ఉపయోగిస్తే, ఫలితంగా వచ్చే బైనరీ డేటా బ్లాక్‌ను ప్రైవేట్ కీని కలిగి ఉన్న వ్యక్తి తప్ప ప్రపంచంలో ఎవరూ ఎక్కడైనా చదవలేరు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Here, we will focus on how public keys are used in the TLS system.","translation":"ఇక్కడ, TLS సిస్టమ్‌లో పబ్లిక్ కీలను ఎలా ఉపయోగిస్తారో దానిపై మేము దృష్టి పెడతాము.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Traditional symmetric-key encryption, where both sides share a big random block of data with which they encrypt outgoing traffic and decrypt incoming traffic, is much faster and better at handling large payloads.","translation":"సాంప్రదాయ సిమెట్రిక్-కీ ఎన్‌క్రిప్షన్, ఇక్కడ రెండు వైపులా పెద్ద యాదృచ్ఛిక డేటా బ్లాక్‌ను పంచుకుంటాయి, దానితో వారు అవుట్‌గోయింగ్ ట్రాఫిక్‌ను గుప్తీకరిస్తారు మరియు ఇన్‌కమింగ్ ట్రాఫిక్‌ను డీక్రిప్ట్ చేస్తారు, ఇది చాలా వేగంగా ఉంటుంది మరియు పెద్ద పేలోడ్‌లను నిర్వహించడంలో మెరుగ్గా ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"So TLS uses public-key cryptography only to begin each conversation: the server sends a public key to the client, the client sends back a suitable symmetric key by encrypting it with the public key, and now both sides hold the same symmetric key without an observer ever having been given the chance to capture it—since the observer will not be able to derive (thanks to powerful mathematics!) the server's private key based on seeing the public key go one way and an encrypted block of data going the other.","translation":"కాబట్టి TLS ప్రతి సంభాషణను ప్రారంభించడానికి మాత్రమే పబ్లిక్-కీ క్రిప్టోగ్రఫీని ఉపయోగిస్తుంది: సర్వర్ క్లయింట్‌కు పబ్లిక్ కీని పంపుతుంది, క్లయింట్ పబ్లిక్ కీతో గుప్తీకరించడం ద్వారా తగిన సిమెట్రిక్ కీని తిరిగి పంపుతుంది మరియు ఇప్పుడు ఇరువైపులా ఒకే సిమెట్రిక్ కీని కలిగి ఉంటాయి, గమనించేవారు దానిని సంగ్రహించే అవకాశం ఇవ్వబడలేదు—గమనించేవారు సర్వర్ యొక్క ప్రైవేట్ కీని పొందలేరు (శక్తివంతమైన గణితానికి ధన్యవాదాలు!) పబ్లిక్ కీ ఒక మార్గంలో వెళ్లడం మరియు గుప్తీకరించబడిన డేటా బ్లాక్ మరొక విధంగా వెళ్లడం ఆధారంగా.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"That alone protects your traffic against sniffing, since an attacker cannot see any of your data by watching from outside, and it also means that he cannot insert, delete, or alter the packets passing across a network node since, without the symmetric key, any change he makes to the data will simply produce gibberish when decrypted.","translation":"ఒక దాడి చేసే వ్యక్తి బయటి నుండి చూసి మీ డేటాను చూడలేనందున, అది ఒక్కటే మీ ట్రాఫిక్‌ను స్నిఫింగ్ నుండి రక్షిస్తుంది మరియు సిమెట్రిక్ కీ లేకుండా, అతను డేటాకు చేసే ఏదైనా మార్పు డీక్రిప్ట్ చేసినప్పుడు కేవలం గిబ్బరిష్‌ను ఉత్పత్తి చేస్తుంది కాబట్టి, నెట్‌వర్క్ నోడ్ ద్వారా వెళ్ళే ప్యాకెట్‌లను అతను చొప్పించలేడు, తొలగించలేడు లేదా మార్చలేడు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Do you remember that the server end of a TLS connection starts by sharing a public key with the client?","translation":"TLS కనెక్షన్ యొక్క సర్వర్ ముగింపు క్లయింట్‌తో పబ్లిక్ కీని పంచుకోవడం ద్వారా ప్రారంభమవుతుందని మీకు గుర్తున్నాయా?","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"If he does not return to you the server's real certificate, then it will not really have been signed by the CA and your TLS library will tell you he is a fake; or, if the attacker does return the server's certificate—since, after all, it is publicly transmitted on the network—then your client will indeed be willing to start talking.","translation":"అతను మీకు సర్వర్ యొక్క అసలు సర్టిఫికేట్‌ను తిరిగి ఇవ్వకపోతే, అది నిజంగా CA ద్వారా సంతకం చేయబడదు మరియు మీ TLS లైబ్రరీ అతను నకిలీ అని మీకు చెబుతుంది; లేదా, దాడి చేసే వ్యక్తి సర్వర్ యొక్క సర్టిఫికేట్‌ను తిరిగి ఇస్తే—అన్నింటికంటే, ఇది నెట్‌వర్క్‌లో బహిరంగంగా ప్రసారం చేయబడుతుంది—అప్పుడు మీ క్లయింట్ నిజంగా మాట్లాడటానికి సిద్ధంగా ఉంటాడు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"These companies stake their reputations on keeping their private keys absolutely safe, and signing server certificates only after making absolutely sure that the request really comes from the owner of a given domain.","translation":"ఈ కంపెనీలు తమ ప్రైవేట్ కీలను పూర్తిగా సురక్షితంగా ఉంచడంపై మరియు అభ్యర్థన నిజంగా ఇచ్చిన డొమైన్ యజమాని నుండి వస్తుందని పూర్తిగా నిర్ధారించిన తర్వాత మాత్రమే సర్వర్ సర్టిఫికేట్‌లపై సంతకం చేయడంపై తమ ఖ్యాతిని పణంగా పెడతాయి.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"If you are setting up TLS servers that will be contacted only by clients that you configure, then you can save money by bypassing the public CAs and generating your own CA public-private key pair.","translation":"మీరు కాన్ఫిగర్ చేసే క్లయింట్‌ల ద్వారా మాత్రమే సంప్రదించబడే TLS సర్వర్‌లను ఏర్పాటు చేస్తుంటే, మీరు పబ్లిక్ CAsని దాటవేయడం ద్వారా మరియు మీ స్వంత CA పబ్లిక్-ప్రైవేట్ కీ జతను రూపొందించడం ద్వారా డబ్బు ఆదా చేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The procedure is simple and is shown in Listing 6–1.","translation":"విధానం సులభం మరియు జాబితా 6–1లో చూపబడింది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"You might get a string from one client, then have to finish sending an answer to a second client.","translation":"మీరు ఒక క్లయింట్ నుండి ఒక స్ట్రింగ్ పొందవచ్చు, ఆపై రెండవ క్లయింట్కు సమాధానం పంపడం పూర్తి చేయాలి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"So we can grudgingly admit that there is a “soft asynchrony” here.","translation":"కాబట్టి ఇక్కడ “మెత్తటి అసమకాలికత” ఉందని మనం అంగీకరించవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"In the same way, understanding the UTF-8 string encoding is useful, but sitting down to write your own encoder in Python is probably a sign that you are re-inventing a wheel.","translation":"అదే విధంగా, UTF-8 స్ట్రింగ్ ఎన్కోడింగ్‌ను అర్థం చేసుకోవడం ఉపయోగకరంగా ఉంటుంది, కానీ పైథాన్‌లో మీ స్వంత ఎన్‌కోడర్‌ను రాయడానికి కూర్చోవడం బహుశా మీరు చక్రం తిరిగి కనుగొంటున్నారనడానికి సంకేతం.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"It is a pair of ancient modules, asyncore and asynchat, that date from the early days of Python.","translation":"ఇది పురాతన మాడ్యూల్స్ జత, asyncore మరియు asynchat, ఇవి పైథాన్ ప్రారంభ రోజుల నాటివి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"If you are curious about these old parts of the Standard Library, then download the source bundle for this book.","translation":"మీకు స్టాండర్డ్ లైబ్రరీ యొక్క ఈ పాత భాగాల గురించి ఆసక్తి ఉంటే, ఈ పుస్తకం కోసం సోర్స్ బండిల్‌ను డౌన్‌లోడ్ చేయండి.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Twisted Python is not simply a framework; it is almost something of a movement.","translation":"ట్విస్టెడ్ పైథాన్ కేవలం ఒక ఫ్రేమ్‌వర్క్ కాదు; ఇది దాదాపు ఒక ఉద్యమం వంటిది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Take a look at Listing 7–8 for how simple our event-driven server can become.","translation":"మన ఈవెంట్-డ్రివెన్ సర్వర్ ఎంత సరళంగా మారగలదో తెలుసుకోవడానికి జాబితా 7–8ని చూడండి.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"From then on, every event on that socket is translated into a method call to our object.","translation":"అప్పటి నుండి, ఆ సాకెట్‌లోని ప్రతి ఈవెంట్ మన ఆబ్జెక్ట్‌కు పద్ధతి కాల్‌గా అనువదించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"But what stops the server from blocking when we call the write() me thod of our data transport?","translation":"కానీ మన డేటా రవాణా యొక్క write() పద్ధతిని పిలిచినప్పుడు సర్వర్ బ్లాక్ అవ్వకుండా ఏమి ఆపుతుంది?","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"There are more methods available on a Twisted Protocol class than we are using here.","translation":"మేము ఇక్కడ ఉపయోగిస్తున్న దానికంటే ట్విస్టెడ్ ప్రోటోకాల్ క్లాస్‌లో మరిన్ని పద్ధతులు అందుబాటులో ఉన్నాయి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The performance of Twisted, as you can see from Figure 7–3, is somewhat lower than that of our handwritten event loop.","translation":"మీరు చిత్రం 7–3 నుండి చూడగలిగినట్లుగా, ట్విస్టెడ్ పనితీరు మన చేతితో రాసిన ఈవెంట్ లూప్ కంటే కొంచెం తక్కువగా ఉంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The real magic of Twisted—which we lack the space to explore here—happens when you write protocols that have to speak to several partners at once rather than just one.","translation":"ట్విస్టెడ్ యొక్క అసలైన మాయాజాలం—దీనిని ఇక్కడ అన్వేషించడానికి మాకు స్థలం లేదు—మీరు ఒకేసారి ఒకటి కంటే ఎక్కువ భాగస్వాములతో మాట్లాడవలసిన ప్రోటోకాల్‌లను రాసినప్పుడు జరుగుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"But what if generating an answer involved reading from disk, or querying another network service, or talking to a local database?","translation":"కానీ సమాధానం రూపొందించడంలో డిస్క్ నుండి చదవడం, లేదా మరొక నెట్‌వర్క్ సేవను ప్రశ్నించడం లేదా స్థానిక డేటాబేస్‌తో మాట్లాడటం వంటివి ఉంటే?","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Error handling becomes the practice of making sure that appropriate error callbacks are always available in case any particular network or I/O operation fails.","translation":"ఏదైనా నిర్దిష్ట నెట్‌వర్క్ లేదా I/O ఆపరేషన్ విఫలమైతే తగిన ఎర్రర్ కాల్‌బ్యాక్‌లు ఎల్లప్పుడూ అందుబాటులో ఉండేలా చూసుకోవడమే ఎర్రర్ హ్యాండ్లింగ్.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"The answer, obviously, is to run several instances of your service and to distribute clients among them.","translation":"సమాధానం, స్పష్టంగా, మీ సేవ యొక్క అనేక ఉదాహరణలను అమలు చేయడం మరియు వాటి మధ్య క్లయింట్‌లను పంపిణీ చేయడం.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"This requires a key piece of software: a load balancer that runs on the port to which all of the clients will be connecting.","translation":"దీనికి ఒక ముఖ్యమైన సాఫ్ట్‌వేర్ అవసరం: అన్ని క్లయింట్‌లు కనెక్ట్ అయ్యే పోర్ట్‌లో నడుస్తున్న లోడ్ బ్యాలెన్సర్.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Load balancers are such critical pieces of infrastructure that they are often built directly into network hardware.","translation":"లోడ్ బ్యాలెన్సర్‌లు మౌలిక సదుపాయాలలో చాలా కీలకమైన భాగాలు, అవి తరచుగా నేరుగా నెట్‌వర్క్ హార్డ్‌వేర్‌లో నిర్మించబడతాయి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"In the old days, it was common to spread load by simply giving a single domain name several different IP addresses.","translation":"పాత రోజుల్లో, ఒకే డొమైన్ పేరుకు అనేక విభిన్న IP చిరునామాలను ఇవ్వడం ద్వారా లోడ్‌ను వ్యాప్తి చేయడం సాధారణం.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The essential idea of a threaded or multi-process server is that we take the simple and straightforward server that we started out with.","translation":"థ్రెడెడ్ లేదా మల్టీ-ప్రాసెస్ సర్వర్ యొక్క ముఖ్యమైన ఆలోచన ఏమిటంటే, మనం ప్రారంభించిన సాధారణ మరియు సూటిగా ఉండే సర్వర్‌ను తీసుకోవడం.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Each thread controls one client socket; it can use blocking recv() and send() calls to wait until data can be received and transmitted.","translation":"ప్రతి థ్రెడ్ ఒక క్లయింట్ సాకెట్‌ను నియంత్రిస్తుంది; డేటాను స్వీకరించడానికి మరియు ప్రసారం చేయడానికి వేచి ఉండటానికి ఇది బ్లాకింగ్ recv() మరియు send() కాల్‌లను ఉపయోగించవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"You are embarking, instead, on an entire discipline of its own known as “concurrent programming,”","translation":"మీరు బదులుగా, “సమకాలీన ప్రోగ్రామింగ్” అని పిలువబడే ఒక ప్రత్యేక విభాగంలోకి ప్రవేశిస్తున్నారు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"First, make sure that you have the difference between threads and processes clear in your head.","translation":"ముందుగా, థ్రెడ్‌లు మరియు ప్రక్రియల మధ్య వ్యత్యాసాన్ని మీ మనస్సులో స్పష్టంగా ఉంచుకోండి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"But if your workers need to talk to one another, then threads let them do so in-memory","translation":"కానీ మీ కార్మికులు ఒకరితో ఒకరు మాట్లాడవలసి వస్తే, థ్రెడ్‌లు వాటిని మెమరీలో చేయడానికి అనుమతిస్తాయి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Second, use high-level data structures whenever possible.","translation":"రెండవది, వీలైతే, అధిక-స్థాయి డేటా నిర్మాణాలను ఉపయోగించండి.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Python provides queues, for example, that can operate either between normal threads (from the queue module) or between processes (see the multiprocessing module).","translation":"ఉదాహరణకు, పైథాన్ క్యూలను అందిస్తుంది, ఇవి సాధారణ థ్రెడ్‌ల మధ్య (క్యూ మాడ్యూల్ నుండి) లేదా ప్రక్రియల మధ్య (మల్టీప్రాసెసింగ్ మాడ్యూల్‌ను చూడండి) పనిచేయగలవు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Third, limit your use of shared data to small and easily protected pieces of code.","translation":"మూడవది, భాగస్వామ్య డేటాను చిన్న మరియు సులభంగా రక్షించబడే కోడ్ ముక్కలకు పరిమితం చేయండి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Choose a few conceptually small points of synchronization where the gears of your program will mesh together, and do your hard thinking there in one place to make sure that your program will operate correctly.","translation":"మీ ప్రోగ్రామ్ యొక్క గేర్లు కలిసిపోయే కొన్ని భావనాత్మకంగా చిన్న సమకాలీకరణ పాయింట్లను ఎంచుకోండి మరియు మీ ప్రోగ్రామ్ సరిగ్గా పనిచేస్తుందని నిర్ధారించుకోవడానికి ఒకే స్థలంలో కష్టపడి ఆలోచించండి.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Finally, look very hard at both the Standard Library and the Package Index for evidence that some other programmer before you has faced the data pattern you are trying to implement and has already taken the time to get it right.","translation":"చివరగా, మీరు అమలు చేయడానికి ప్రయత్నిస్తున్న డేటా నమూనాను మీ ముందు కొంతమంది ఇతర ప్రోగ్రామర్లు ఎదుర్కొన్నారనడానికి మరియు దానిని సరిగ్గా పొందడానికి ఇప్పటికే సమయం తీసుకున్నారనడానికి స్టాండర్డ్ లైబ్రరీ మరియు ప్యాకేజీ ఇండెక్స్‌ను చాలా జాగ్రత్తగా చూడండి.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"That, I believe, is the way to go about writing network services: write code that concerns itself with local variables and local effects, and that leaves all of the issues of locking and concurrency to people like database designers that are good at that sort of thing.","translation":"నెట్‌వర్క్ సేవలను ఎలా రాయాలనే దాని గురించి నేను నమ్ముతున్నాను: స్థానిక వేరియబుల్స్ మరియు స్థానిక ప్రభావాలతో సంబంధం ఉన్న కోడ్‌ను రాయండి మరియు లాకింగ్ మరియు కన్కరెన్సీకి సంబంధించిన అన్ని సమస్యలను డేటాబేస్ డిజైనర్‌ల వంటి వ్యక్తులకు వదిలివేయండి.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Back then, the RAM used by each running process was a substantial annoyance.","translation":"అప్పట్లో, ప్రతి రన్నింగ్ ప్రాసెస్ ఉపయోగించే RAM ఒక ముఖ్యమైన అసౌకర్యం.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Today, of course, even the Ubuntu laptop on which I am typing is running dozens of services just to power things like the weather widget in my toolbar, and the machine’s response time seems downright snappy despite running—let’s see—wow, 229 separate processes all at the same time.","translation":"నేడు, నేను టైప్ చేస్తున్న ఉబుంటు ల్యాప్‌టాప్ కూడా నా టూల్‌బార్‌లోని వాతావరణ విడ్జెట్ వంటి వాటిని శక్తివంతం చేయడానికి డజన్ల కొద్దీ సేవలను నడుపుతోంది మరియు మెషిన్ యొక్క ప్రతిస్పందన సమయం నడుస్తున్నప్పటికీ చాలా వేగంగా ఉంది—చూద్దాం—వావ్, ఒకే సమయంలో 229 ప్రత్యేక ప్రక్రియలు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"So the idea was to have an /etc/inetd.conf file where you could list all of the services you wanted to provide, along with the name of the program that should be run to answer each request.","translation":"కాబట్టి మీరు అందించాలనుకుంటున్న అన్ని సేవల జాబితాను కలిగి ఉండే /etc/inetd.conf ఫైల్‌ను కలిగి ఉండాలనే ఆలోచన, ప్రతి అభ్యర్థనకు సమాధానం ఇవ్వడానికి అమలు చేయవలసిన ప్రోగ్రామ్ పేరుతో పాటు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"If you are writing a Python service to be run from inetd, the client socket returned by the inetd accept() call will be passed in as your standard input and output.","translation":"మీరు inetd నుండి అమలు చేయడానికి పైథాన్ సేవను రాస్తుంటే, inetd accept() కాల్ ద్వారా తిరిగి వచ్చిన క్లయింట్ సాకెట్ మీ ప్రామాణిక ఇన్‌పుట్ మరియు అవుట్‌పుట్‌గా అందించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Network servers typically need to run as daemons so that they do not exit when a particular user logs out, and since they will have no controlling terminal, they will need to log their activity to files so that administrators can monitor and debug them.","translation":"నెట్‌వర్క్ సర్వర్‌లు సాధారణంగా డీమన్‌లుగా అమలు చేయవలసి ఉంటుంది, తద్వారా ఒక నిర్దిష్ట వినియోగదారు లాగ్ అవుట్ అయినప్పుడు అవి నిష్క్రమించవు మరియు వాటికి నియంత్రణ టెర్మినల్ ఉండదు కాబట్టి, నిర్వాహకులు వాటిని పర్యవేక్షించడానికి మరియు డీబగ్ చేయడానికి వాటి కార్యాచరణను ఫైల్‌లకు లాగ్ చేయాలి.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"One approach to network programming is to write an event-driven program, or use an event-driven framework like Twisted Python.","translation":"నెట్‌వర్క్ ప్రోగ్రామింగ్‌కు ఒక విధానం ఏమిటంటే, ఈవెంట్-డ్రివెన్ ప్రోగ్రామ్‌ను రాయడం లేదా ట్విస్టెడ్ పైథాన్ వంటి ఈవెంట్-డ్రివెన్ ఫ్రేమ్‌వర్క్‌ను ఉపయోగించడం.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Threads are a weak solution under C Python because the Global Interpreter Lock prevents any two of them from both running Python code at the same time","translation":"C పైథాన్ కింద థ్రెడ్‌లు బలహీనమైన పరిష్కారం, ఎందుకంటే గ్లోబల్ ఇంటర్‌ప్రెటర్ లాక్ వాటిలో రెండింటినీ ఒకే సమయంలో పైథాన్ కోడ్‌ను అమలు చేయకుండా నిరోధిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"In ancient times, people ran network services through inetd, which hands each server an already- accepted client connection as its standard input and output.","translation":"పురాతన కాలంలో, ప్రజలు నెట్‌వర్క్ సేవలను inetd ద్వారా నడిపించారు, ఇది ఇప్పటికే అంగీకరించబడిన క్లయింట్ కనెక్షన్‌ను ప్రతి సర్వర్‌కు దాని ప్రామాణిక ఇన్‌పుట్ మరియు అవుట్‌పుట్‌గా అందిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Its impact on many large Internet services has been, by all accounts, revolutionary.","translation":"అనేక పెద్ద ఇంటర్నెట్ సేవలపై దాని ప్రభావం, అన్ని ఖాతాల ద్వారా, విప్లవాత్మకంగా ఉంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"You run a Memcached daemon on every server with some spare memory.","translation":"మీరు కొంత ఖాళీ మెమరీతో ప్రతి సర్వర్‌లో Memcached డీమన్‌ను అమలు చేస్తారు.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Your client programs now have access to an organization-wide blazing-fast key- value cache that acts something like a big Python dictionary that all of your servers can share.","translation":"మీ క్లయింట్ ప్రోగ్రామ్‌లు ఇప్పుడు సంస్థ-వ్యాప్త బ్లేజింగ్-ఫాస్ట్ కీ-విలువ కాష్‌ను యాక్సెస్ చేయగలవు, ఇది మీ సర్వర్లన్నీ భాగస్వామ్యం చేయగల పెద్ద పైథాన్ నిఘంటువులా పనిచేస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"The GET method is still the backbone of the protocol today.","translation":"ఈ రోజుకీ GET పద్ధతి ప్రోటోకాల్ యొక్క వెన్నెముకగా ఉంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"It is very important to get this boundary strictly correct when writing an HTTP implementation.","translation":"ఒక HTTP అమలును రాసేటప్పుడు ఈ సరిహద్దును ఖచ్చితంగా సరిగ్గా పొందడం చాలా ముఖ్యం.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Web servers, in practice, have absolute freedom to interpret URLs as they please.","translation":"వెబ్ సర్వర్లు, ఆచరణలో, URLలను తమకు నచ్చిన విధంగా అర్థం చేసుకునే పూర్తి స్వేచ్ఛను కలిగి ఉంటాయి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The simplest relative links are the names of pages one level deeper than the base page.","translation":"అతి సాధారణ సంబంధిత లింక్‌లు బేస్ పేజీ కంటే ఒక స్థాయి లోతులో ఉన్న పేజీల పేర్లు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"This indicates that each page was fetched successfully.","translation":"ప్రతి పేజీ విజయవంతంగా పొందబడిందని ఇది సూచిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"The request has succeeded.","translation":"అభ్యర్థన విజయవంతమైంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"The resource that used to live at this URL has been assigned a new URL.","translation":"ఈ URLలో నివసించిన వనరుకు కొత్త URL కేటాయించబడింది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The original URL should continue to be used for this request.","translation":"ఈ అభ్యర్థన కోసం అసలు URLని ఉపయోగించడం కొనసాగించాలి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The URL does not name a valid resource.","translation":"URL చెల్లుబాటు అయ్యే వనరు పేరును సూచించదు.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"The web site is broken.","translation":"వెబ్‌సైట్ పనిచేయడం లేదు.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"This is the code included when Twitter displays its famous Fail Whale, for example.","translation":"ఉదాహరణకు, Twitter దాని ప్రసిద్ధ ఫెయిల్ వేల్‌ను ప్రదర్శించినప్పుడు చేర్చబడిన కోడ్ ఇది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"By catching the exception, we can both see how the HTTP response looked on the wire.","translation":"అసాధారణ పరిస్థితిని పట్టుకోవడం ద్వారా, తీగపై HTTP ప్రతిస్పందన ఎలా ఉందో మనం చూడవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Redirections are very common on the World Wide Web.","translation":"ప్రపంచవ్యాప్త వెబ్‌లో దారిమార్పులు చాలా సాధారణం.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Google, for example, likes those three letters to be included.","translation":"ఉదాహరణకు, Google ఆ మూడు అక్షరాలను చేర్చడానికి ఇష్టపడుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"You cannot tell by looking at the response whether a redirect occurred.","translation":"పునరుద్ధరణ జరిగిందా లేదా అని ప్రతిస్పందనను చూడటం ద్వారా మీరు చెప్పలేరు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Keep in mind that downloading a modern web page","translation":"ఒక ఆధునిక వెబ్ పేజీని డౌన్‌లోడ్ చేస్తున్నప్పుడు గుర్తుంచుకోండి","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"For example, consider a very simple URL like the following: http://python.org","translation":"ఉదాహరణకు, కింది విధంగా చాలా సాధారణ URLని పరిగణించండి: http://python.org","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The hostname example.com will be resolved to an IP.","translation":"హోస్ట్‌నేమ్ example.com IPకి పరిష్కరించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Any characters beyond the alphanumerics must be percent-encoded.","translation":"ఆల్ఫాన్యూమరిక్‌లకు మించిన ఏదైనా అక్షరాలను శాతం-ఎన్‌కోడ్ చేయాలి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"This is because any anchor is stripped off and is not turned into part of the HTTP request.","translation":"ఎందుకంటే ఏదైనా యాంకర్‌ను తీసివేయబడుతుంది మరియు HTTP అభ్యర్థనలో భాగంగా మార్చబడదు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"The pipeline makes sure that every queued message is delivered to exactly one consumer.","translation":"ప్రతి క్యూలో ఉన్న సందేశం ఖచ్చితంగా ఒక వినియోగదారునికి మాత్రమే డెలివరీ చేయబడుతుందని పైప్‌లైన్ నిర్ధారిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"But subscribers typically want to receive all of the messages that are being enqueued by each publisher.","translation":"కానీ సాధారణంగా, చందాదారులు ప్రతి ప్రచురణకర్త ద్వారా క్యూలో ఉంచబడుతున్న అన్ని సందేశాలను స్వీకరించాలనుకుంటారు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"This kind of queue can be used to power external services that need to push events to the outside world.","translation":"ఈ రకమైన క్యూ ఈవెంట్‌లను బయటి ప్రపంచానికి పంపించాల్సిన బాహ్య సేవలకు శక్తినివ్వడానికి ఉపయోగించవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Finally, a request-reply pattern is often the most complex because messages have to make a round- trip.","translation":"చివరగా, అభ్యర్థన-ప్రత్యుత్తర నమూనా తరచుగా చాలా క్లిష్టమైనది, ఎందుకంటే సందేశాలు రౌండ్-ట్రిప్ చేయాలి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The queue itself, to support this, has to feature some sort of addressing scheme.","translation":"దీనికి మద్దతు ఇవ్వడానికి, క్యూలో ఏదో ఒక రకమైన చిరునామా పథకం ఉండాలి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Request-reply queues are a great way to connect lightweight workers.","translation":"అభ్యర్థన-ప్రత్యుత్తర క్యూలు తేలికైన కార్మికులను కనెక్ట్ చేయడానికి గొప్ప మార్గం.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Messaging seems to have been popular in the Java world before it started becoming the rage among Python programmers.","translation":"పైథాన్ ప్రోగ్రామర్‌లలో ఇది ఒక క్రేజ్‌గా మారడానికి ముందే జావా ప్రపంచంలో సందేశం బాగా ప్రాచుర్యం పొందినట్లు అనిపిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"A competing approach that is much more in line with the Internet philosophy of open standards.","translation":"ఓపెన్ స్టాండర్డ్స్ యొక్క ఇంటర్నెట్ తత్వశాస్త్రానికి అనుగుణంగా ఉన్న పోటీ విధానం.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"There are several AMQP implementations currently listed in the Python Package Index.","translation":"ప్రస్తుతం పైథాన్ ప్యాకేజీ ఇండెక్స్‌లో అనేక AMQP అమలులు జాబితా చేయబడ్డాయి.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Future readers will want to read recent blog posts and success stories.","translation":"భవిష్యత్ పాఠకులు ఇటీవలి బ్లాగ్ పోస్ట్‌లు మరియు విజయ కథలను చదవాలనుకుంటున్నారు.","target_lang":"te","domain":"general","complexity":"simple"}
{"en":"An alternative to using AMQP and having to run a central broker is to use ØMQ.","translation":"AMQPని ఉపయోగించడానికి మరియు సెంట్రల్ బ్రోకర్‌ను అమలు చేయడానికి ఒక ప్రత్యామ్నాయం ØMQని ఉపయోగించడం.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"You should probably focus on the particular message pattern that you need to implement.","translation":"మీరు అమలు చేయవలసిన నిర్దిష్ట సందేశ నమూనాపై మీరు దృష్టి పెట్టాలి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"If you are using messages as simply a lightweight and load-balanced form of RPC.","translation":"మీరు సందేశాలను తేలికైన మరియు లోడ్-బ్యాలెన్స్డ్ RPC రూపంగా ఉపయోగిస్తుంటే.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Listing 8–3 shows some of the patterns that can be supported when message queues are used.","translation":"జాబితా 8–3 సందేశ క్యూలను ఉపయోగించినప్పుడు మద్దతు ఇవ్వగల కొన్ని నమూనాలను చూపుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Whatever message queue you use, I should warn you that it may very well cause a revolution in your thinking.","translation":"మీరు ఏ సందేశ క్యూని ఉపయోగించినా, ఇది మీ ఆలోచనలో విప్లవం కలిగిస్తుందని నేను మీకు హెచ్చరించాలి.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Before you encounter message queues, you tend to consider the function or method call to be the basic mechanism.","translation":"మీరు సందేశ క్యూలను ఎదుర్కొనే ముందు, మీరు ఫంక్షన్ లేదా మెథడ్ కాల్‌ను ప్రాథమిక విధానంగా భావిస్తారు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Once you start using message queues, however, your entire approach toward service architecture may begin to experience a Copernican revolution.","translation":"అయితే, మీరు సందేశ క్యూలను ఉపయోగించడం ప్రారంభించిన తర్వాత, సేవా ఆర్కిటెక్చర్ పట్ల మీ మొత్తం విధానం కోపర్నికన్ విప్లవాన్ని అనుభవించడం ప్రారంభించవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"The queued message, rather than the library API, will become the fundamental point of rendezvous in your application.","translation":"లైబ్రరీ APIకి బదులుగా, క్యూలో ఉన్న సందేశం మీ అప్లికేషన్‌లో సమావేశం యొక్క ప్రాథమిక అంశంగా మారుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"When all of your application’s work and resources are present within a single address space.","translation":"మీ అప్లికేషన్ యొక్క మొత్తం పని మరియు వనరులు ఒకే చిరునామా స్థలంలో ఉన్నప్పుడు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Message queues also offer resilience and flexibility.","translation":"సందేశ క్యూలు స్థితిస్థాపకత మరియు సౌలభ్యాన్ని కూడా అందిస్తాయి.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"The HTTPConnection class provided by urllib2 lets you take advantage of this feature.","translation":"urllib2 అందించే HTTPConnection తరగతి ఈ ఫీచర్ని ఉపయోగించుకోవడానికి మిమ్మల్ని అనుమతిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"In fact, all requests go through one of these objects.","translation":"వాస్తవానికి, అన్ని అభ్యర్థనలు ఈ వస్తువులలో ఒకదాని ద్వారా వెళతాయి.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"When you might make several requests to the same site, use a persistent connection instead.","translation":"మీరు ఒకే సైట్‌కు చాలా అభ్యర్థనలు చేసినప్పుడు, బదులుగా నిరంతర కనెక్షన్‌ని ఉపయోగించండి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"You can see here that two successive requests are indeed using the same socket object.","translation":"ఇక్కడ రెండు వరుస అభ్యర్థనలు నిజంగా ఒకే సాకెట్ వస్తువును ఉపయోగిస్తున్నాయని మీరు చూడవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"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.","translation":"RFC 2616 కనెక్షన్: అనే పేరుతో ఒక హెడర్‌ను నిర్వచిస్తుంది, ఇది ఒక అభ్యర్థన సాకెట్‌పై చేయబడే చివరిది అని స్పష్టంగా సూచించడానికి ఉపయోగించవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"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.","translation":"ఒక సాకెట్ మూసివేయబడినప్పుడు మరియు మరొకటి సృష్టించవలసి వచ్చినప్పుడు HTTPConnection మినహాయింపును పెంచదని గమనించండి; మీరు ఒకే వస్తువును పదేపదే ఉపయోగించవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"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.","translation":"HTTP 1.0 (మరియు అంతకు ముందు) రోజుల్లో, కనెక్షన్‌ను మూసివేయడం అనేది డాక్యుమెంట్ ప్రసారం పూర్తయిందని సూచించడానికి అధికారిక మార్గం.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"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.","translation":"కంటెంట్-లెంగ్త్ హెడర్ ఈ రోజు చాలా ముఖ్యమైనది, ఎందుకంటే ఇది క్లయింట్ తదుపరి ప్రతిస్పందన ఎక్కడ ప్రారంభమవుతుందో గందరగోళానికి గురికాకుండా ఒకే సాకెట్ నుండి అనేక HTTP ప్రతిస్పందనలను చదవడానికి అనుమతిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"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.","translation":"ఒక పొడవును అందించలేనప్పుడు—అంటే, సర్వర్ ముందే ఊహించలేని డేటాను ప్రసారం చేస్తోంది కాబట్టి—అప్పుడు సర్వర్ ముక్కలుగా విభజించబడిన ఎన్‌కోడింగ్‌ను ఉపయోగించవచ్చు, ఇక్కడ అది చిన్న ముక్కల శ్రేణిని పంపుతుంది, ప్రతి ఒక్కటి వాటి పొడవుతో ముందుగా అమర్చబడి ఉంటాయి.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"The POST HTTP method was designed to power web forms.","translation":"POST HTTP పద్ధతి వెబ్ ఫారమ్‌లకు శక్తినివ్వడానికి రూపొందించబడింది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"But what about a login form that accepts your e-mail address and password?","translation":"కానీ మీ ఇమెయిల్ చిరునామా మరియు పాస్‌వర్డ్‌ను అంగీకరించే లాగిన్ ఫారమ్ గురించి ఏమిటి?","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"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.","translation":"వెబ్‌సైట్‌లో నిర్దిష్ట పేజీ లేదా స్థానం పేరును నిర్మించని ఫారమ్‌ల కోసం POST పద్ధతిని ఎల్లప్పుడూ ఉపయోగించాలి, కానీ బదులుగా కాలర్ తరపున కొన్ని చర్యలను నిర్వహిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Instead of stuffing form parameters into the URL, a POST carries them in the body of the request.","translation":"ఫారమ్ పారామితులను URL లోకి నింపడానికి బదులుగా, POST వాటిని అభ్యర్థన యొక్క శరీరంలో తీసుకువెళుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The GET method means, “I believe that there is a document at this URL; please return it.”","translation":"GET పద్ధతి అంటే, “ఈ URL వద్ద ఒక పత్రం ఉందని నేను నమ్ముతున్నాను; దయచేసి దానిని తిరిగి ఇవ్వండి.”","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The POST method means, “Here is an action that I want performed.”","translation":"POST పద్ధతి అంటే, “నేను నిర్వహించాలనుకుంటున్న ఒక చర్య ఇది.”","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Note that POST must always be the method used for actions on the Web that have side effects.","translation":"వెబ్‌లో సైడ్ ఎఫెక్ట్‌లను కలిగి ఉన్న చర్యల కోసం POSTని ఎల్లప్పుడూ ఉపయోగించాల్సిన పద్ధతి అని గమనించండి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Successful Form POSTs Should Always Redirect","translation":"విజయవంతమైన ఫారమ్ POSTలు ఎల్లప్పుడూ దారి మళ్లించాలి","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"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.","translation":"ఈ కారణాలన్నింటికీ, బాగా రూపొందించబడిన వినియోగదారు-ముఖ POST ఫారమ్‌లు ఎల్లప్పుడూ చర్య ఫలితాన్ని చూపించే పేజీకి దారి మళ్లిస్తాయి మరియు ఈ పేజీని సురక్షితంగా బుక్‌మార్క్ చేయవచ్చు, షేర్ చేయవచ్చు, నిల్వ చేయవచ్చు మరియు మళ్లీ లోడ్ చేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"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.","translation":"ఒక మినహాయింపు ఏమిటంటే, విజయవంతం కాని POST వెంటనే ఫారమ్‌ను మళ్లీ ప్రదర్శించాలి, దాని ఫీల్డ్‌లు ఇప్పటికే నింపబడి ఉంటాయి—వినియోగదారుని మళ్లీ ప్రతిదీ టైప్ చేయవద్దు!—మరియు వారి లోపాలు లేదా లోపాలను గుర్తించాలి, తద్వారా వినియోగదారు వాటిని సరిదిద్దవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"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.","translation":"చివరి రెండు విభాగాలలో ఇచ్చిన దాదాపు ఏ హెచ్చరికలు వెబ్ బ్రౌజర్ కాకుండా ప్రోగ్రామ్ ద్వారా వినియోగానికి HTTP POST రూపొందించబడినప్పుడు వర్తించవు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"The program saves the result to phoenix.html.","translation":"ప్రోగ్రామ్ ఫలితాన్ని phoenix.htmlకి సేవ్ చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"We are able to download a forecast page using only a few lines of code.","translation":"మేము కొన్ని లైన్ల కోడ్‌ని ఉపయోగించి మాత్రమే ఒక సూచన పేజీని డౌన్‌లోడ్ చేయగలుగుతున్నాము.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The library itself will take responsibility for exploring the HTML and letting you know what forms are present.","translation":"HTMLని అన్వేషించడానికి మరియు ఏ ఫారమ్‌లు ఉన్నాయో మీకు తెలియజేయడానికి లైబ్రరీయే బాధ్యత తీసుకుంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Here, mechanize has helped us avoid reading any HTML at all.","translation":"ఇక్కడ, మెకనైజ్ ఏ HTMLని చదవకుండా ఉండటానికి మాకు సహాయం చేసింది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"We can write a program like that shown in Listing 10–2.","translation":"లిస్టింగ్ 10–2లో చూపిన విధంగా మనం ఒక ప్రోగ్రామ్‌ను వ్రాయవచ్చు.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"I prefer not to rely on the order, since the real identity of a form is inherent in the action that it performs.","translation":"నేను ఆర్డర్‌పై ఆధారపడకూడదనుకుంటున్నాను, ఎందుకంటే ఒక ఫారమ్ యొక్క అసలు గుర్తింపు అది చేసే చర్యలో అంతర్లీనంగా ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"I avoid using mechanize for simple form submission.","translation":"నేను సాధారణ ఫారమ్ సమర్పణ కోసం మెకనైజ్‌ని ఉపయోగించకుండా ఉంటాను.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"These web sessions require a visit to the front page anyway.","translation":"ఈ వెబ్ సెషన్‌లకు ముందు పేజీని సందర్శించడం అవసరం.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"The Hypertext Markup Language (HTML) is one of many markup dialects.","translation":"హైపర్టెక్స్ట్ మార్కప్ లాంగ్వేజ్ (HTML) అనేక మార్కప్ మాండలికాలలో ఒకటి.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Inserting bold and italics into a format like HTML is as simple as typing eight angle brackets.","translation":"HTML వంటి ఫార్మాట్‌లో బోల్డ్ మరియు ఇటాలిక్‌లను చొప్పించడం ఎనిమిది కోణపు బ్రాకెట్‌లను టైప్ చేయడం అంత సులభం.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Elements can contain text as well as other elements.","translation":"మూలకాలు వచనాన్ని అలాగే ఇతర మూలకాలను కలిగి ఉంటాయి.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"The problem with SGML languages in this regard is that they expect parsers to know the rules.","translation":"ఈ విషయంలో SGML భాషలతో సమస్య ఏమిటంటే, పార్సర్‌లు నియమాలను తెలుసుకోవాలని వారు ఆశిస్తారు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"At first this might look like a series of <li> elements that are more and more deeply nested.","translation":"మొదట ఇది లోతుగా అమర్చబడిన <li> మూలకాల శ్రేణిలా కనిపించవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"This has resulted not only in a World Wide Web that is full of sites with invalid and broken HTML markup.","translation":"దీని ఫలితంగా చెల్లని మరియు విరిగిన HTML మార్కప్‌తో సైట్‌లతో నిండిన వరల్డ్ వైడ్ వెబ్ ఏర్పడింది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"You can find abundant resources online.","translation":"మీరు ఆన్‌లైన్‌లో పుష్కలంగా వనరులను కనుగొనవచ్చు.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"We will now turn to that weather forecast for Phoenix, Arizona.","translation":"ఇప్పుడు మనం అరిజోనాలోని ఫీనిక్స్ కోసం వాతావరణ సూచన వైపుకు మళ్లుతాము.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Parsing HTML with Python requires three choices.","translation":"Pythonతో HTMLని పార్సింగ్ చేయడానికి మూడు ఎంపికలు అవసరం.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"The issue of selectors is a very important one.","translation":"ఎంపికల సమస్య చాలా ముఖ్యమైనది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"An experienced web developer looking at that list rearranges it in her head.","translation":"అనుభవజ్ఞుడైన వెబ్ డెవలపర్ ఆ జాబితాను చూసి తన మనసులో తిరిగి అమర్చుకుంటాడు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Deep nesting is a very common feature of complicated page designs.","translation":"డీప్ నెస్టింగ్ అనేది సంక్లిష్టమైన పేజీ డిజైన్‌ల యొక్క చాలా సాధారణ లక్షణం.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"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.","translation":"POST, PUT లేదా DELETE అభ్యర్థన ద్వారా ప్రభావితమయ్యే వెబ్ వనరులను చెల్లనివిగా మార్చడం గురించి వెబ్ కాష్‌లు కూడా ఆందోళన చెందాలి, ఎందుకంటే ఆ కార్యకలాపాలు వినియోగదారులకు తిరిగి వచ్చే డేటాను మార్చవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Caching proxies are tricky things to write and require a vast attention span with respect to reading standards!","translation":"కాషింగ్ ప్రాక్సీలను రాయడం కష్టం మరియు ప్రమాణాలను చదవడం విషయంలో చాలా శ్రద్ధ అవసరం!","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"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.","translation":"urllib2 లేదా mechanize రెండూ కాషింగ్‌కు మద్దతు ఇచ్చినట్లు అనిపించదు; కాబట్టి మీకు స్థానిక కాష్ అవసరమైతే, మీరు Python ప్యాకేజీ సూచికలో అందుబాటులో ఉన్న httplib2 మాడ్యూల్‌ను చూడవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"In this case, you can issue a HEAD request.","translation":"ఈ సందర్భంలో, మీరు HEAD అభ్యర్థనను జారీ చేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"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.","translation":"మీ ప్రోగ్రామ్ లింక్‌ల శ్రేణిని చెల్లుబాటు కోసం లేదా అవి తరలించబడ్డాయో లేదో తనిఖీ చేయాలని మీరు కోరుకోవచ్చు, కానీ HTTP హెడర్‌లను అనుసరించే బాడీని వాస్తవానికి డౌన్‌లోడ్ చేసే ఖర్చును మీరు భరించకూడదనుకుంటున్నారు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"You can see that the body of the response is completely empty.","translation":"ప్రతిస్పందన యొక్క బాడీ పూర్తిగా ఖాళీగా ఉందని మీరు చూడవచ్చు.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"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.","translation":"కానీ కంప్యూటర్‌లోని ప్రాసెసర్ వేగం మరియు ఇతర ఉపవ్యవస్థల మధ్య మూర్స్ లా తెరిచిన గొప్ప లోటు ఏమిటంటే, వినియోగదారు డేటా లేదా గుర్తింపుకు రక్షణ అవసరమయ్యే ప్రతిచోటా SSLని అమలు చేయకపోవడానికి ఎటువంటి కారణం లేదు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"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.","translation":"Google తన GMail సేవను HTTPS-మాత్రమేకి మార్చినప్పుడు, సర్టిఫికేట్ మరియు ఎన్‌క్రిప్షన్ రొటీన్‌లు సర్వర్ CPU వినియోగానికి కొన్ని శాతం మాత్రమే జోడిస్తున్నాయని కంపెనీ పేర్కొంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"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.","translation":"గుప్తీకరించబడిన URL కేవలం http:కి బదులుగా https:తో ప్రారంభమవుతుంది, పోర్ట్ 80కి బదులుగా డిఫాల్ట్ పోర్ట్ 443ని ఉపయోగిస్తుంది మరియు TLSని ఉపయోగిస్తుంది; TLS/SSL ఎలా పనిచేస్తుందో గుర్తుంచుకోవడానికి అధ్యాయం 6ని సమీక్షించండి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"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.","translation":"గుప్తీకరణ వెబ్ సర్వర్‌లను ఒక సందిగ్ధతలో ఉంచుతుంది: వినియోగదారు తన HTTP అభ్యర్థనను పంపే ముందు గుప్తీకరణను చర్చించాలి, లేకపోతే దానిలోని మొత్తం సమాచారం వెల్లడి చేయబడుతుంది; కానీ అభ్యర్థన ప్రసారం అయ్యే వరకు, అభ్యర్థన ఏ హోస్ట్‌ను పేర్కొంటుందో సర్వర్‌కు తెలియదు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"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.","translation":"అందువల్ల, గుప్తీకరించబడిన వెబ్‌సైట్‌లు హోస్ట్ చేయవలసిన ప్రతి డొమైన్ కోసం వేరే IP చిరునామాను ఉపయోగించాల్సిన పాత సమస్య కింద ఇప్పటికీ జీవిస్తున్నాయి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"A technique known as “Server Name Indication” (SNI) has been developed to get around this traditional restriction; however, Python does not yet support it.","translation":"ఈ సాంప్రదాయ పరిమితిని అధిగమించడానికి “సర్వర్ నేమ్ ఇండికేషన్” (SNI) అని పిలువబడే ఒక సాంకేతికత అభివృద్ధి చేయబడింది; అయితే, Python ఇంకా దీనికి మద్దతు ఇవ్వలేదు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"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!","translation":"ఆశాజనకంగా, రాబోయే ఒకటి లేదా రెండు సంవత్సరాలలో ఈ పుస్తకం యొక్క Python 3 ఎడిషన్ ఉంటుంది, ఇది SNI పూర్తిగా urllib2 ద్వారా మద్దతు ఇవ్వబడుతుందని సంతోషంగా నివేదించగలదు!","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"To use HTTPS from Python, simply supply an https: method in your URL:","translation":"Python నుండి HTTPSని ఉపయోగించడానికి, మీ URLలో https: పద్ధతిని అందించండి:","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"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.","translation":"కనెక్షన్ సరిగ్గా పని చేస్తే, మీరు ఉపయోగించిన శోధన పదం లేదా మీరు వీక్షించిన ఫలితాలను మీ ప్రభుత్వం లేదా అలాంటి విషయాలను ట్రాక్ చేసే వివిధ పెద్ద మరియు నీడ కార్పొరేషన్‌లలో ఏదీ సులభంగా గుర్తించలేవు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"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.","translation":"HTTP ప్రోటోకాల్ ప్రామాణీకరణతో వచ్చింది, ఇది చాలా పేలవంగా ఆలోచించబడింది మరియు చాలా చెడ్డగా అమలు చేయబడింది, ఇది దాదాపు పూర్తిగా వదిలివేయబడినట్లు అనిపిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"When a server was asked for a page to which access was restricted, it was supposed to return a response code:","translation":"యాక్సెస్ పరిమితం చేయబడిన పేజీని సర్వర్ అడిగినప్పుడు, అది ప్రతిస్పందన కోడ్‌ను తిరిగి ఇవ్వాలి:","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"This indicated that the server did not know who was requesting the resource, so it could not decide whether to grant permission.","translation":"వనరును ఎవరు అభ్యర్థిస్తున్నారో సర్వర్‌కు తెలియదని ఇది సూచిస్తుంది, కాబట్టి అనుమతి ఇవ్వాలా వద్దా అని అది నిర్ణయించలేకపోయింది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"By asking for Basic authentication, the site would induce the web browser to pop up a dialog box asking for a username and password.","translation":"ప్రాథమిక ప్రామాణీకరణను అడగడం ద్వారా, సైట్ వెబ్ బ్రౌజర్‌ను వినియోగదారు పేరు మరియు పాస్‌వర్డ్‌ను అడుగుతూ డైలాగ్ బాక్స్ తెరవడానికి ప్రేరేపిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The authentication token was generated by doing base64 encoding on the colon-separated username and password:","translation":"గుర్తింపు ప్రమాణీకరణ టోకెన్ కాలన్-వేరు చేయబడిన వినియోగదారు పేరు మరియు పాస్‌వర్డ్‌పై base64 ఎన్‌కోడింగ్ చేయడం ద్వారా రూపొందించబడింది:","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The application handles HTTP requests and uses start_response().","translation":"అప్లికేషన్ HTTP అభ్యర్థనలను నిర్వహిస్తుంది మరియు start_response()ని ఉపయోగిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Generators are useful for loading large files without using much memory.","translation":"ఎక్కువ మెమరీని ఉపయోగించకుండా పెద్ద ఫైల్‌లను లోడ్ చేయడానికి జనరేటర్లు ఉపయోగపడతాయి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The WSGI server concatenates strings to produce the response body.","translation":"WSGI సర్వర్ స్పందన బాడీని ఉత్పత్తి చేయడానికి స్ట్రింగ్‌లను కలుపుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"A 404 error is returned if the URL doesn't match any existing pages.","translation":"URL ఏ పేజీతోనూ సరిపోలకపోతే 404 ఎర్రర్ తిరిగి వస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Content types must be correctly paired with documents.","translation":"విషయ రకాలు పత్రాలతో సరిగ్గా జత చేయాలి.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"User input needs to be meticulously quoted to prevent issues.","translation":"సమస్యలను నివారించడానికి వినియోగదారు ఇన్‌పుట్‌ను ఖచ్చితంగా ఉదహరించాలి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Web frameworks provide tools for handling URLs and user input.","translation":"వెబ్ ఫ్రేమ్‌వర్క్‌లు URLలు మరియు వినియోగదారు ఇన్‌పుట్‌ను నిర్వహించడానికి సాధనాలను అందిస్తాయి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"WSGI middleware allows for modifying requests and responses.","translation":"WSGI మిడిల్‌వేర్ అభ్యర్థనలు మరియు ప్రతిస్పందనలను సవరించడానికి అనుమతిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Middleware can delegate requests to the correct application.","translation":"మిడిల్‌వేర్ అభ్యర్థనలను సరైన అప్లికేషన్‌కు పంపగలదు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Authentication can be delegated to WSGI middleware.","translation":"గుర్తింపును WSGI మిడిల్‌వేర్‌కు అప్పగించవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Theming can be a problem when combining multiple applications.","translation":"బహుళ అప్లికేషన్‌లను కలిపినప్పుడు థీమింగ్ ఒక సమస్య కావచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Debuggers can display annotated tracebacks for exceptions.","translation":"డీబగ్గర్‌లు మినహాయింపుల కోసం వ్యాఖ్యానించబడిన ట్రేస్‌బ్యాక్‌లను ప్రదర్శించగలవు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Python web programmers often use web frameworks.","translation":"పైథాన్ వెబ్ ప్రోగ్రామర్లు తరచుగా వెబ్ ఫ్రేమ్‌వర్క్‌లను ఉపయోగిస్తారు.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"WSGI has not become the standard mechanism for web applications.","translation":"WSGI వెబ్ అప్లికేషన్‌ల కోసం ప్రామాణిక విధానంగా మారలేదు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The WSGI middleware approach uses a component stack.","translation":"WSGI మిడిల్‌వేర్ విధానం ఒక భాగాల స్టాక్‌ను ఉపయోగిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Django is a popular framework for building web sites.","translation":"వెబ్‌సైట్‌లను నిర్మించడానికి డిజాంగో ఒక ప్రసిద్ధ ఫ్రేమ్‌వర్క్.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Python 3 has a rigorous approach to byte and Unicode strings.","translation":"పైథాన్ 3 బైట్ మరియు యూనికోడ్ స్ట్రింగ్‌లకు కఠినమైన విధానాన్ని కలిగి ఉంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Web frameworks help programmers step back from HTTP details.","translation":"వెబ్ ఫ్రేమ్‌వర్క్‌లు ప్రోగ్రామర్‌లు HTTP వివరాల నుండి వెనక్కి తగ్గడానికి సహాయపడతాయి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Templates re-orient our attention in web development.","translation":"వెబ్ అభివృద్ధిలో టెంప్లేట్‌లు మన దృష్టిని మళ్ళిస్తాయి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Choosing a web framework is an important decision.","translation":"వెబ్ ఫ్రేమ్‌వర్క్‌ను ఎంచుకోవడం ఒక ముఖ్యమైన నిర్ణయం.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"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.","translation":"HTML పై XPath: తరగతి లక్షణానికి ఖాళీలను ముందుగా చేర్చడం మరియు జోడించడం ద్వారా, సెలెక్టర్ లక్ష్య తరగతి పేరు చుట్టూ ఖాళీలతో చూసుకోవచ్చని మరియు పేరు తరగతుల జాబితాలో ఎక్కడ ఉన్నా సరిపోతుందని నిర్ధారిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Selectors, then, can make it simple, elegant, and also quite fast to find elements deep within a document that interest us.","translation":"అప్పుడు, సెలెక్టర్లు మనకు ఆసక్తి కలిగించే డాక్యుమెంట్ లోతుల్లోని మూలకాలను కనుగొనడం సులభం, సొగసైనది మరియు చాలా వేగంగా చేయగలవు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"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.","translation":"మరియు డాక్యుమెంట్ ను తిరిగి రూపొందించినందున లేదా మేము ఊహించని మూలన సందర్భం కారణంగా అవి విచ్ఛిన్నమైతే, మేము మొదట ప్రయత్నించిన డాక్యుమెంట్ ట్రీని నడిచే శ్రమతో కూడుకున్న మరియు లోతైన విధానానికి భిన్నంగా, అవి స్పష్టమైన మార్గాల్లో విచ్ఛిన్నమయ్యే అవకాశం ఉంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"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.","translation":"మీకు ఆసక్తి కలిగించే డాక్యుమెంట్ యొక్క భాగాన్ని మీరు గుర్తించిన తర్వాత, మీకు అవసరమైన టెక్స్ట్ లేదా లక్షణ విలువలను పొందడానికి ElementTree లేదా పాత BeautifulSoup APIని ఉపయోగించడం సాధారణంగా చాలా సులభం.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"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!","translation":"మొదటి స్ట్రింగ్ యూనికోడ్ ఆబ్జెక్ట్‌గా తిరిగి రాకపోవడం మీకు చికాకు కలిగిస్తే, మీరు ఎలిమెంట్ ట్రీ ప్రమాణాన్ని నిందించాలి; లోపం Python 3లో సరిదిద్దబడింది!","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"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.","translation":"దీనికి కొంచెం అలవాటు పడవచ్చు మరియు ఇది ఇలా పనిచేస్తుంది: <p> నా అభిమాన నాటకం # <p> మూలకం యొక్క .text <i> » హామ్లెట్ # <i> మూలకం యొక్క .text </i> ఇది నిజంగా కాదు # <i> మూలకం యొక్క .tail <b> » డానిష్ # <b> మూలకం యొక్క .text </b> కానీ ఇంగ్లీష్.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"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.","translation":"ఇది గందరగోళంగా ఉంటుంది, ఎందుకంటే మీరు మూడు పదాలు ఇష్టమైనవి మరియు నిజంగా మరియు ఇంగ్లీష్ ఒకే “స్థాయి”లో ఉన్నాయని భావిస్తారు—అన్నీ <p> మూలకం యొక్క పిల్లలు—కానీ lxml మొదటి పదాన్ని మాత్రమే <p> మూలకానికి జోడించిన టెక్స్ట్ లో భాగంగా పరిగణిస్తుంది మరియు మిగిలిన రెండింటినీ లోపలి <i> మరియు <b> మూలకాల యొక్క తోక వచనాలకు చెందినవిగా పరిగణిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"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.","translation":"దీనికి విరుద్ధంగా, బ్యూటిఫుల్‌సూప్, టెక్స్ట్ ముక్కలు మరియు <font> ట్యాగ్ లోపల ఉన్న <br> మూలకాలను దాని శ్రేణి యొక్క అదే స్థాయిలో కూర్చున్న పిల్లలుగా పరిగణిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Strings of text, in other words, are treated as phantom elements.","translation":"మాటల స్ట్రింగ్‌లను, ఇతర మాటలలో, ఫాంటమ్ మూలకాలుగా పరిగణిస్తారు.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Through a similar operation, we can direct either lxml or BeautifulSoup to the humidity datum.","translation":"ఒకే విధమైన ఆపరేషన్ ద్వారా, మనం lxml లేదా బ్యూటిఫుల్‌సూప్‌ను తేమ డేటమ్‌కు నిర్దేశించవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"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.","translation":"తేమ: అనే పదం ఎల్లప్పుడూ సంఖ్యా విలువ పక్కన డాక్యుమెంట్‌లో అక్షరాలా సంభవిస్తుంది కాబట్టి, ఈ శోధన పెద్ద CSS ట్యాగ్ వంటి యాదృచ్ఛికంగా కాకుండా అర్థవంతమైన పదం ద్వారా నడపబడుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"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.","translation":"మరియు ఇక్కడ మీరు చూడవచ్చు, అత్యుత్తమంగా వివరించబడింది, స్క్రీన్ స్క్రాపింగ్ ఎల్లప్పుడూ చివరి ఆశ్రయం యొక్క విధానం మరియు మీరు డేటాను మరేదైనా మార్గంలో పొందగలిగితే ఎల్లప్పుడూ నివారించాలి: ఎందుకంటే ప్రెజెంటేషన్ మార్కప్ సాధారణంగా ఒక విషయం కోసం రూపొందించబడింది—బ్రౌజర్‌లలో మానవ రీడబిలిటీ—మరియు ఇది ప్రదర్శించే దానిపై ఆధారపడి పిచ్చి మార్గాల్లో మారవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"What is the problem here?","translation":"ఇక్కడ సమస్య ఏమిటి?","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"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.","translation":"ఒక చిన్న పరిశోధన NWS పేజీ <tr> లోపల <font> మూలకాన్ని మాత్రమే కలిగి ఉందని సూచిస్తుంది—మరియు ఇది కొన్ని ఉదాహరణలపై ఆధారపడి, నా అంచనా మాత్రమే—ప్రస్తుత పరిస్థితుల వివరణ చాలా పదాలు కలిగి ఉంది మరియు అందువల్ల ఖాళీని కలిగి ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"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.","translation":"నేను ఈ అధ్యాయాన్ని వ్రాసినప్పుడు ఫీనిక్స్ లోని పరిస్థితులు “కొన్ని మేఘాలు,” కాబట్టి మునుపటి కోడ్ బాగా పనిచేసింది; అధ్యాయం 10 ■ స్క్రీన్ స్క్రాపింగ్ 176 కానీ స్ప్రింగ్‌ఫీల్డ్‌లో వాతావరణం “ఫెయిర్”గా ఉంది మరియు అందువల్ల దాని చుట్టూ <font> కవచం అవసరం లేదు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"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.","translation":"మీరు జాబితా 10–4 యొక్క తుది రూపాన్ని చూస్తే, వివిధ నగరాలతో ఫార్మాట్‌లో మార్పులను గమనించినప్పుడు నేను చేసిన కొన్ని ఇతర మార్పులను మీరు చూస్తారు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"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:","translation":"ఇప్పుడు ఇది సహేతుకమైన స్థానాల ఎంపికకు వ్యతిరేకంగా పనిచేస్తున్నట్లు కనిపిస్తుంది; మళ్ళీ, ఇది ఒకే నివేదికను రెండుసార్లు ఇస్తుందని గమనించండి, ఒకసారి lxmlతో మరియు ఒకసారి బ్యూటిఫుల్‌సూప్‌తో రూపొందించబడింది:","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"You will note that some cities have spaces between the temperature and the F, and others do not.","translation":"కొన్ని నగరాల్లో ఉష్ణోగ్రత మరియు F మధ్య ఖాళీలు ఉన్నాయని మీరు గమనించవచ్చు, మరికొన్నిటికి లేవు.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"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.","translation":"ఎల్క్ సిటీ, ఓక్లహోమాలోని ఉష్ణోగ్రత కోసం వెబ్ పేజీ ప్రస్తుతం “NULL” అనే పదాన్ని ఎందుకు ప్రదర్శిస్తుందో తెలుసుకోవడానికి నేను పాఠకుడికి ఒక వ్యాయామంగా వదిలివేస్తున్నాను—మీరు దీన్ని బ్రౌజర్‌లో కూడా చూడవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Screen scraping is, at bottom, a complete mess.","translation":"స్క్రీన్ స్క్రాపింగ్, దిగువన, పూర్తి గందరగోళం.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"The email module in Python can read a message from a file or a string.","translation":"పైథాన్ లోని ఇమెయిల్ మాడ్యూల్ ఫైల్ లేదా స్ట్రింగ్ నుండి సందేశాన్ని చదవగలదు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"You can even make adjustments to the message, and then generate a fresh version.","translation":"మీరు సందేశానికి సర్దుబాట్లు కూడా చేయవచ్చు, ఆపై కొత్త వెర్షన్‌ను రూపొందించవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"This program is short and simple.","translation":"ఈ ప్రోగ్రామ్ చిన్నది మరియు సులభమైనది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"For each object it encounters, it checks to see if it is multipart.","translation":"అది ఎదుర్కొనే ప్రతి వస్తువు కోసం, అది బహుళ భాగమా కాదా అని తనిఖీ చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Individual parts of a message can easily be extracted.","translation":"సందేశంలోని వ్యక్తిగత భాగాలను సులభంగా సంగ్రహించవచ్చు.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Fortunately, the email module can decode them all!","translation":"అదృష్టవశాత్తూ, ఇమెయిల్ మాడ్యూల్ వాటన్నింటినీ డీకోడ్ చేయగలదు!","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"This program steps through the message, like the last example.","translation":"ఈ ప్రోగ్రామ్ చివరి ఉదాహరణ వలె సందేశం ద్వారా వెళుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"We skip asking the user about message components that are multipart.","translation":"బహుళ భాగాలైన సందేశ భాగాల గురించి వినియోగదారుని అడగడాన్ని మేము దాటవేస్తాము.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"When run, the program looks something like this.","translation":"రన్ చేసినప్పుడు, ప్రోగ్రామ్ ఇలా కనిపిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"The function decode_header() takes a single header and returns a list of pieces.","translation":"decode_header() ఫంక్షన్ ఒకే హెడర్‌ను తీసుకుంటుంది మరియు ముక్కల జాబితాను అందిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"It is always good practice to use decode_header() on any of the “big three” headers.","translation":"ఎప్పుడూ “పెద్ద మూడు” శీర్షికలలో దేనిపైనైనా decode_header()ని ఉపయోగించడం మంచిది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Traditional e-mail messages contain headers and a body.","translation":"సాంప్రదాయ ఇమెయిల్ సందేశాలలో శీర్షికలు మరియు బాడీ ఉంటాయి.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Python’s e-mail modules can both generate messages and parse messages.","translation":"పైథాన్ యొక్క ఇమెయిల్ మాడ్యూల్స్ సందేశాలను రూపొందించగలవు మరియు సందేశాలను విశ్లేషించగలవు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"To generate a traditional message, an instance of email.mime.text.MIMEText or email.message.Message can be created.","translation":"సాంప్రదాయ సందేశాన్ని రూపొందించడానికి, email.mime.text.MIMEText లేదా email.message.Message యొక్క ఉదాహరణను సృష్టించవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"MIME is a set of extensions to the e-mail format.","translation":"MIME అనేది ఇమెయిల్ ఫార్మాట్‌కు సంబంధించిన పొడిగింపుల సమితి.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Multipart MIME messages can be used for attachments and alternative views.","translation":"అటాచ్‌మెంట్‌లు మరియు ప్రత్యామ్నాయ వీక్షణల కోసం బహుళ భాగాల MIME సందేశాలను ఉపయోగించవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The first generations of e-mail users were given usernames and passwords.","translation":"మొదటి తరం ఇమెయిల్ వినియోగదారులకు వినియోగదారు పేర్లు మరియు పాస్‌వర్డ్‌లు ఇవ్వబడ్డాయి.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"The actual means of bridging this small gap was a mere implementation detail.","translation":"ఈ చిన్న అంతరాన్ని తగ్గించే అసలు మార్గం కేవలం అమలు వివరాలు మాత్రమే.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The first widespread e-mail daemon, sendmail, came with a program for submitting e-mail.","translation":"మొదటి విస్తృతమైన ఇమెయిల్ డీమన్, sendmail, ఇమెయిల్ సమర్పించడానికి ఒక ప్రోగ్రామ్‌తో వచ్చింది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The next generation of users were often not familiar with the idea of a command line.","translation":"తదుపరి తరం వినియోగదారులు తరచుగా కమాండ్ లైన్ ఆలోచనతో సుపరిచితులు కాదు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Your Python programs need to send emails.","translation":"మీ పైథాన్ ప్రోగ్రామ్‌లు ఇమెయిల్‌లను పంపించాలి.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Successfully sending email often requires a queue.","translation":"విజయవంతంగా ఇమెయిల్ పంపడానికి తరచుగా క్యూ అవసరం.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"You typically don't want your programs to send mail directly.","translation":"మీరు సాధారణంగా మీ ప్రోగ్రామ్‌లు నేరుగా మెయిల్ పంపాలని కోరుకోరు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Writing a full mail transfer agent is a big job.","translation":"పూర్తి మెయిల్ బదిలీ ఏజెంట్‌ను రాయడం ఒక పెద్ద పని.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Take advantage of existing MTAs before writing your own.","translation":"మీ స్వంతంగా రాయడానికి ముందు ఇప్పటికే ఉన్న MTAలను ఉపయోగించుకోండి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Your system administrator might have an opinion on how your program sends mail.","translation":"మీ ప్రోగ్రామ్ మెయిల్ ఎలా పంపుతుందో మీ సిస్టమ్ నిర్వాహకుడికి ఒక అభిప్రాయం ఉండవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Make an authenticated SMTP connection to an existing e-mail server.","translation":"ఉన్న ఇమెయిల్ సర్వర్‌కు ప్రమాణీకరించబడిన SMTP కనెక్షన్‌ను చేయండి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Use a username and password for your application.","translation":"మీ అప్లికేషన్ కోసం వినియోగదారు పేరు మరియు పాస్‌వర్డ్‌ను ఉపయోగించండి.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Run a local binary like the sendmail program.","translation":"sendmail ప్రోగ్రామ్ వంటి స్థానిక బైనరీని అమలు చేయండి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The addressee headers are not consulted by the SMTP protocol.","translation":"SMTP ప్రోటోకాల్ ద్వారా గ్రహీత శీర్షికలను సంప్రదించరు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"The protocol knows only that each message has an envelope.","translation":"ప్రతి సందేశానికి ఒక కవరు ఉందని ప్రోటోకాల్‌కు తెలుసు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The Bcc header names people who you want to receive the mail without other recipients knowing.","translation":"Bcc హెడర్ ఇతర గ్రహీతలకు తెలియకుండా మీరు మెయిల్ అందుకోవాలని కోరుకునే వ్యక్తుల పేర్లను కలిగి ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Your e-mail client edits your message's headers before sending it.","translation":"మీ ఇమెయిల్ క్లయింట్ పంపే ముందు మీ సందేశం యొక్క శీర్షికలను సవరిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"An e-mail can pass across SMTP toward a destination address that is mentioned nowhere in the e-mail headers.","translation":"ఇమెయిల్ శీర్షికలలో ఎక్కడా పేర్కొనబడని గమ్యస్థాన చిరునామాకు SMTP ద్వారా ఇమెయిల్ వెళ్ళవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"This mechanism also helps support mailing lists.","translation":"ఈ విధానం మెయిలింగ్ జాబితాలకు కూడా మద్దతు ఇస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"E-mail often travels through multiple servers before reaching its destination.","translation":"ఇమెయిల్ తరచుగా గమ్యస్థానానికి చేరుకోవడానికి ముందు బహుళ సర్వర్ల ద్వారా ప్రయాణిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The SMTP envelope recipient repeatedly changes as the message nears its destination.","translation":"సందేశం దాని గమ్యస్థానానికి చేరువవుతున్నప్పుడు SMTP కవరు గ్రహీత పదేపదే మారుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"E-mail servers are encouraged to write new headers.","translation":"ఇమెయిల్ సర్వర్లు కొత్త శీర్షికలను వ్రాయడానికి ప్రోత్సహించబడతాయి.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"The smtplib module makes it easy to do simple tasks with SMTP.","translation":"smtplib మాడ్యూల్ SMTPతో సాధారణ పనులను చేయడం సులభం చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"This program uses a very powerful and general function from inside the Standard Library.","translation":"ఈ ప్రోగ్రామ్ స్టాండర్డ్ లైబ్రరీ లోపల నుండి చాలా శక్తివంతమైన మరియు సాధారణ ఫంక్షన్‌ను ఉపయోగిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Python provides an email.utils.formatdate() routine that will generate dates in the right format.","translation":"పైథాన్ email.utils.formatdate() అనే రూటీన్‌ను అందిస్తుంది, ఇది సరైన ఫార్మాట్‌లో తేదీలను ఉత్పత్తి చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"You should add a Message-ID header to messages.","translation":"మీరు సందేశాలకు Message-ID శీర్షికను జోడించాలి.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"This header should be generated in such a way that no other e-mail, anywhere in history, will ever have the same Message-ID.","translation":"చరిత్రలో మరెక్కడా లేని విధంగా, ఏ ఇతర ఇమెయిల్ కూడా అదే Message-IDని కలిగి ఉండకుండా ఈ శీర్షికను రూపొందించాలి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"This might sound difficult, but Python provides a function to help do that as well: email.utils.make_msgid().","translation":"ఇది కష్టంగా అనిపించవచ్చు, కానీ పైథాన్ కూడా అలా చేయడానికి సహాయపడే ఒక ఫంక్షన్‌ను అందిస్తుంది: email.utils.make_msgid().","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"If you run the program, you will notice two new headers in the output.","translation":"మీరు ప్రోగ్రామ్‌ను అమలు చేస్తే, అవుట్‌పుట్‌లో రెండు కొత్త శీర్షికలను మీరు గమనించవచ్చు.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"The message is now ready to send!","translation":"సందేశాన్ని పంపడానికి ఇప్పుడు సిద్ధంగా ఉంది!","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"You might be curious how the unique Message-ID is created.","translation":"ప్రత్యేకమైన Message-ID ఎలా సృష్టించబడిందో మీకు ఆసక్తి ఉండవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"It is generated by adhering to a set of loose guidelines.","translation":"ఇది కొన్ని సడలించిన మార్గదర్శకాలకు అనుగుణంగా ఉత్పత్తి చేయబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The part to the right of the @ is the full hostname of the machine that is generating the e-mail message.","translation":"@ కుడి వైపున ఉన్న భాగం ఇమెయిల్ సందేశాన్ని ఉత్పత్తి చేస్తున్న మెషిన్ యొక్క పూర్తి హోస్ట్ పేరు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"This helps prevent the message ID from being the same as the IDs generated on entirely different computers.","translation":"ఇది పూర్తిగా వేర్వేరు కంప్యూటర్‌లలో ఉత్పత్తి చేయబడిన IDల వలె సందేశ ID ఒకేలా ఉండకుండా సహాయపడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"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.","translation":"ఎడమ వైపున ఉన్న భాగం సాధారణంగా తేదీ, సమయం, సందేశాన్ని ఉత్పత్తి చేసే ప్రోగ్రామ్ యొక్క ప్రాసెస్ ID మరియు కొన్ని యాదృచ్ఛిక డేటాను ఉపయోగించి ఉత్పత్తి చేయబడుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"This combination of data tends to work well in practice in making sure every message can be uniquely identified.","translation":"ప్రతి సందేశాన్ని ప్రత్యేకంగా గుర్తించగలదని నిర్ధారించుకోవడానికి ఆచరణలో డేటా యొక్క ఈ కలయిక బాగా పనిచేస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"But what happens when you receive an incoming message as a raw block of text and want to look inside?","translation":"కానీ మీరు ఇన్‌కమింగ్ సందేశాన్ని ముడి టెక్స్ట్ బ్లాక్‌గా స్వీకరించినప్పుడు మరియు లోపలికి చూడాలనుకున్నప్పుడు ఏమి జరుగుతుంది?","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"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.","translation":"సరే, ఇమెయిల్ మాడ్యూల్ ఇమెయిల్ సందేశాలను పార్సింగ్ చేయడానికి కూడా మద్దతును అందిస్తుంది, మొదట సందేశాన్ని సృష్టించడానికి ఉపయోగించిన అదే Message వస్తువును తిరిగి నిర్మిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"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.","translation":"సందేశాన్ని పార్స్ చేసిన తర్వాత, మీరు సందేశాలను సృష్టించడానికి ఉపయోగించిన అదే నిబంధనలను ఉపయోగించి వ్యక్తిగత శీర్షికలు మరియు సందేశం యొక్క బాడీని సులభంగా యాక్సెస్ చేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"headers look like the dictionary key-values of the Message, and the body can be fetched with a function.","translation":"శీర్షికలు సందేశం యొక్క నిఘంటువు కీ-విలువలు వలె కనిపిస్తాయి మరియు బాడీని ఒక ఫంక్షన్‌తో పొందవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"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.","translation":"అనేక ఇమెయిల్ క్లయింట్‌ల వలె, ఈ పార్సర్ వినియోగదారులు నిజంగా కనిపించాలని కోరుకునే కొన్ని ఇమెయిల్ శీర్షికల మధ్య — ఫ్రమ్ మరియు సబ్జెక్ట్ వంటివి — మరియు వారికి ఆసక్తి కలిగించే అవకాశం తక్కువగా ఉన్న అదనపు శీర్షికల మధ్య వ్యత్యాసాన్ని చూపుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Here, the “unpopular” Message-ID header, which most users just want hidden, is shown first.","translation":"ఇక్కడ, చాలా మంది వినియోగదారులు దాచాలనుకునే “అనాదరణ పొందిన” Message-ID శీర్షిక మొదట చూపబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Then, the headers actually of interest to the user are printed.","translation":"అప్పుడు, వినియోగదారునికి నిజంగా ఆసక్తి కలిగించే శీర్షికలు ముద్రించబడతాయి.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Finally, the body of the e-mail message is displayed on the screen.","translation":"చివరగా, ఇమెయిల్ సందేశం యొక్క బాడీ తెరపై ప్రదర్శించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"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.","translation":"మీకు బ్రౌజర్‌కు ఈవెంట్‌లను అందించడానికి కోమెట్ లాంటి విధానం వంటి నిర్దిష్ట అధునాతన ఫీచర్‌లు అవసరమైతే, ఆ అవసరమైన ఫీచర్‌లను బాగా అమలు చేసే ఫ్రేమ్‌వర్క్‌ను మీరు ఖచ్చితంగా చూడాలి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Choosing the best tool for the job sometimes involves combining several tools, instead of demanding everything from a single monolithic application.","translation":"పని కోసం ఉత్తమ సాధనాన్ని ఎంచుకోవడం కొన్నిసార్లు ఒకే మోనోలిథిక్ అప్లికేషన్ నుండి ప్రతిదీ డిమాండ్ చేయడానికి బదులుగా అనేక సాధనాలను కలపడం కలిగి ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Finally, understand that experience is often the best guide to choosing a web framework.","translation":"చివరిగా, వెబ్ ఫ్రేమ్‌వర్క్‌ను ఎంచుకోవడానికి అనుభవం తరచుగా ఉత్తమ మార్గదర్శి అని అర్థం చేసుకోండి.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"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.","translation":"అంటే, అన్ని విండో షాపింగ్ తర్వాత, మీరు కూర్చుని, అందుబాటులో ఉన్న వివిధ ఫ్రేమ్‌వర్క్‌లలో కొన్నింటిలో వాస్తవానికి రాయడానికి ప్రయత్నించాలి, ఇచ్చిన ఫ్రేమ్‌వర్క్ మీకైనా లేదా మీ సమస్యకైనా సరిపోతుందో లేదో మీకు నిజంగా తెలిసే ముందు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Remember that, whatever framework you choose, you are writing Python code.","translation":"మీరు ఏ ఫ్రేమ్‌వర్క్‌ను ఎంచుకున్నా, మీరు పైథాన్ కోడ్‌ను వ్రాస్తున్నారని గుర్తుంచుకోండి.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"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.","translation":"అంటే మీ అప్లికేషన్ యొక్క నాణ్యత మంచి, శుభ్రమైన, పైథానిక్ కోడ్‌ను వ్రాయగల మీ సామర్థ్యంపై ఆధారపడి ఉంటుంది, ఇది ఫ్రేమ్‌వర్క్ యొక్క మాయా లక్షణాలపై ఆధారపడి ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"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.","translation":"ఫ్రేమ్‌వర్క్ మీకు కొంచెం ఇబ్బందికరంగా అనిపించవచ్చు లేదా మీరు విభేదించే సీనియర్ టీమ్ సభ్యుడు దీన్ని ఎంచుకోవచ్చు; కానీ ఇది పైథాన్ అని మరియు దాని సౌలభ్యం మరియు చక్కదనం సాధారణంగా మీరు మంచి వెబ్ అప్లికేషన్‌ను వ్రాయడానికి వీలు కల్పిస్తుందని ఎల్లప్పుడూ గుర్తుంచుకోండి, మీరు చివరికి ఏ ఫ్రేమ్‌వర్క్‌ను ఉపయోగిస్తున్నా.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"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.","translation":"పైథాన్ “బ్యాటరీలతో వస్తుంది” అని నిరూపించడానికి ఒక సరదా మార్గం ఏమిటంటే, మీ సిస్టమ్‌లోని డైరెక్టరీని నమోదు చేసి, సింపుల్‌హెచ్‌టిటిపిసర్వర్ స్టాండర్డ్ లైబ్రరీ మాడ్యూల్‌ను స్వతంత్ర ప్రోగ్రామ్‌గా అమలు చేయడం.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"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.","translation":"మీరు మీ బ్రౌజర్‌ను localhost:8000కి మళ్లించినట్లయితే, మీరు బ్రౌజింగ్ కోసం ఈ స్క్రిప్ట్ యొక్క ప్రస్తుత డైరెక్టరీలోని విషయాలను చూస్తారు, ఉదాహరణకు, ఒక సైట్ డైరెక్టరీని బ్రౌజ్ చేయడానికి వదిలివేసినప్పుడు అపాచీ అందించిన జాబితాలు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"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.","translation":"మీరు ఎంచుకున్నప్పుడు డాక్యుమెంట్‌లు మరియు చిత్రాలు మీ వెబ్ బ్రౌజర్‌లో లోడ్ అవుతాయి, mimetypes స్టాండర్డ్ లైబ్రరీ మాడ్యూల్ యొక్క ఉత్తమ అంచనాల ద్వారా ఎంచుకున్న కంటెంట్ రకాల ఆధారంగా.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The SimpleHTTPServer is a subclass of BaseHTTPServer, which is also the foundation of the wsgiref.simple_server that we looked at earlier.","translation":"సింపుల్‌హెచ్‌టిటిపిసర్వర్ అనేది బేస్‌హెచ్‌టిటిపిసర్వర్ యొక్క ఉపవర్గం, ఇది మనం ఇంతకు ముందు చూసిన wsgiref.simple_server యొక్క ఆధారం కూడా.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Before the WSGI standard was invented, small Python programs could subclass BaseHTTPServer if they needed to answer raw HTTP requests.","translation":"WSGI ప్రమాణం కనుగొనబడటానికి ముందు, చిన్న పైథాన్ ప్రోగ్రామ్‌లు ముడి HTTP అభ్యర్థనలకు సమాధానం ఇవ్వవలసి వస్తే బేస్‌హెచ్‌టిటిపిసర్వర్‌ను ఉపవర్గం చేయగలవు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"This is actually a common difference between the old mechanisms by which Python programs provided extensibility, and the more modern and Pythonic mechanisms.","translation":"పైథాన్ ప్రోగ్రామ్‌లు విస్తరణను అందించే పాత విధానాలు మరియు మరింత ఆధునిక మరియు పైథానిక్ విధానాల మధ్య ఇది వాస్తవానికి ఒక సాధారణ వ్యత్యాసం.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"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.","translation":"ఒక తరగతిని లోపల స్టబ్ పద్ధతులతో రాయడం మరియు ప్రోగ్రామర్‌లను సబ్‌క్లాసింగ్ చేయడం మరియు ఆ పద్ధతులను నిర్వచించడం ద్వారా విస్తరించమని చెప్పడం ఒకప్పుడు ప్రసిద్ధి చెందింది; నేడు, మేము విస్తరణ యొక్క చాలా శుభ్రమైన రూపాలను అందించడానికి నేమ్‌స్పేస్‌లు, కాల్‌బుల్స్ మరియు డక్-టైప్ చేసిన వస్తువులను ఉపయోగిస్తాము.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"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).","translation":"ఉదాహరణకు, నేడు start_response వంటి ఒక వస్తువు ఒక వాదనగా అందించబడుతుంది (ఆధారపడటం ఇంజెక్షన్), మరియు WSGI ప్రమాణం దాని వారసత్వ వృక్షానికి బదులుగా దాని ప్రవర్తనను పేర్కొంటుంది (డక్ టైపింగ్).","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"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).","translation":"ప్రామాణిక లైబ్రరీలో మరో రెండు HTTP సర్వర్లు ఉన్నాయి: CGIHTTPServer సింపుల్‌హెచ్‌టిటిపిసర్వర్‌ను తీసుకుంటుంది మరియు డిస్క్ నుండి స్టాటిక్ ఫైల్‌లను అందించడానికి బదులుగా, ఇది CGI స్క్రిప్ట్‌లను అమలు చేసే సామర్థ్యాన్ని జోడిస్తుంది (దీనిని మనం తదుపరి విభాగంలో కవర్ చేస్తాము).","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"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.","translation":"సింపుల్‌ఎక్స్‌ఎంఎల్‌ఆర్‌పిసిసర్వర్ మరియు డాక్స్‌ఎంఎల్‌ఆర్‌పిసిసర్వర్ రెండూ ఒక సర్వర్ ఎండ్‌పాయింట్‌ను అందిస్తాయి, దీనికి వ్యతిరేకంగా క్లయింట్ ప్రోగ్రామ్‌లు చాప్టర్ 18 మరియు జాబితా 22-1లో చూపిన విధంగా XML-RPC రిమోట్ విధాన కాల్‌లను చేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"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.","translation":"మునుపటి సర్వర్లలో ఏదీ సాధారణంగా ఉత్పత్తి వినియోగానికి ఉద్దేశించబడలేదని గమనించండి; బదులుగా, సిస్టమ్ లేదా సబ్‌నెట్‌కు అంతర్గతంగా ఉన్న ఇతర సేవల ద్వారా ఉపయోగించబడే శీఘ్ర HTTP ఎండ్‌పాయింట్ మీకు అవసరమైన చిన్న అంతర్గత పనులకు అవి ఉపయోగపడతాయి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"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.","translation":"మరియు చాలా పైథాన్ వెబ్ ఫ్రేమ్‌వర్క్‌లు డీబగ్గింగ్ కోసం కమాండ్ లైన్ నుండి మీ అప్లికేషన్‌ను అమలు చేయడానికి ఒక మార్గాన్ని అందిస్తుండగా, చాలా మంది డీబగ్గింగ్ కోసం అభివృద్ధి ప్లాట్‌ఫారమ్‌ను ఉపయోగించకుండా సిఫార్సు చేయడంలో జాంగోను అనుసరిస్తారు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"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.","translation":"అయితే, కొన్ని పైథాన్ వెబ్ ఫ్రేమ్‌వర్క్‌లు ఉన్నాయి, ఇవి వాటి స్వంత అంతర్నిర్మిత HTTP సర్వర్‌లను అందించడమే కాకుండా, వాటి భద్రత మరియు పనితీరుపై కూడా పని చేశాయి, తద్వారా వాటిని ఉత్పత్తిలో ఉపయోగించడానికి సిఫార్సు చేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"If not, then the remote server does not support TLS and the message can only be sent normally, in the clear.","translation":"అలా కాకపోతే, రిమోట్ సర్వర్ TLSకు మద్దతు ఇవ్వదు మరియు సందేశాన్ని సాధారణంగా, స్పష్టంగా మాత్రమే పంపవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Call starttls() to initiate the encrypted channel.","translation":"గుప్తీకరించబడిన ఛానెల్‌ను ప్రారంభించడానికి starttls()ని కాల్ చేయండి.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Call ehlo() a second time; this time, it’s encrypted.","translation":"రెండవసారి ehlo()ని కాల్ చేయండి; ఈసారి, ఇది గుప్తీకరించబడింది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Finally, send your message.","translation":"చివరిగా, మీ సందేశాన్ని పంపండి.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"The first question you have to ask yourself when working with TLS is whether you should return an error if TLS is not available.","translation":"TLSతో పని చేస్తున్నప్పుడు మీరు మిమ్మల్ని మీరు ప్రశ్నించుకోవలసిన మొదటి ప్రశ్న ఏమిటంటే, TLS అందుబాటులో లేకపోతే మీరు లోపాన్ని తిరిగి ఇవ్వాలా వద్దా?","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Depending on your application, you might want to raise an error for any of the following:","translation":"మీ అప్లికేషన్‌ను బట్టి, మీరు కింది వాటిలో దేనికైనా లోపాన్ని పెంచవచ్చు:","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"There is no support for TLS on the remote side.","translation":"రిమోట్ వైపు TLSకి మద్దతు లేదు.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"The remote side fails to establish a TLS session properly.","translation":"రిమోట్ వైపు TLS సెషన్‌ను సరిగ్గా ఏర్పాటు చేయడంలో విఫలమవుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The remote server presents a certificate that cannot be validated.","translation":"రిమోట్ సర్వర్ ధృవీకరించలేని సర్టిఫికేట్‌ను అందిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Let us step through each of these scenarios and see when they may deserve an error message.","translation":"ఈ దృశ్యాలలో ప్రతి ఒక్కటి ద్వారా వెళ్దాం మరియు అవి ఎప్పుడు లోపం సందేశానికి అర్హత పొందుతాయో చూద్దాం.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"First, it is sometimes appropriate to treat a lack of support for TLS altogether as an error.","translation":"ముందుగా, TLSకి మద్దతు లేకపోవడాన్ని మొత్తం లోపంగా పరిగణించడం కొన్నిసార్లు సముచితం.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"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.","translation":"మీరు పరిమిత సంఖ్యలో మెయిల్ సర్వర్‌లకు మాత్రమే మాట్లాడే అప్లికేషన్‌ను వ్రాస్తుంటే ఇది కావచ్చు— బహుశా మీ కంపెనీ నడుపుతున్న మెయిల్ సర్వర్‌లు TLSకి మద్దతు ఇవ్వాలని మీకు తెలుసు లేదా TLSకి మద్దతు ఇస్తుందని మీకు తెలిసిన బ్యాంకు నడుపుతున్న మెయిల్ సర్వర్‌లు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"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.","translation":"కానీ నేడు ఇంటర్నెట్‌లో చాలా తక్కువ సంఖ్యలో మెయిల్ సర్వర్‌లు TLSకి మద్దతు ఇస్తున్నందున, సాధారణంగా మెయిల్ ప్రోగ్రామ్ దాని లేకపోవడాన్ని లోపంగా పరిగణించకూడదు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Many TLS-aware SMTP clients will use TLS if available, but will fall back on standard, unsecured transmission otherwise.","translation":"అనేక TLS-అవేర్ SMTP క్లయింట్‌లు అందుబాటులో ఉంటే TLSని ఉపయోగిస్తాయి, కానీ లేకపోతే ప్రామాణిక, సురక్షితం కాని ప్రసారంపై పడిపోతాయి.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"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.","translation":"దీనిని అవకాశవాద ఎన్‌క్రిప్షన్ అంటారు మరియు అన్ని కమ్యూనికేషన్‌లను గుప్తీకరించమని బలవంతం చేయడం కంటే తక్కువ సురక్షితం, కానీ సామర్థ్యం ఉన్నప్పుడు సందేశాలను రక్షిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Second, sometimes a remote server claims to be TLS-aware but then fails to properly establish a TLS connection.","translation":"రెండవది, కొన్నిసార్లు రిమోట్ సర్వర్ TLS-అవేర్ అని పేర్కొంటుంది, కానీ TLS కనెక్షన్‌ను సరిగ్గా ఏర్పాటు చేయడంలో విఫలమవుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"This is often due to a misconfiguration on the server’s end.","translation":"ఇది తరచుగా సర్వర్ ముగింపులో తప్పు కాన్ఫిగరేషన్ కారణంగా జరుగుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"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.","translation":"వీలైనంత దృఢంగా ఉండటానికి, మీరు గుప్తీకరించడానికి కూడా ప్రయత్నించని కొత్త కనెక్షన్‌తో అలాంటి సర్వర్‌కు మీ ప్రసారాన్ని మళ్లీ ప్రయత్నించాలని కోరుకోవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Third, there is the situation where you cannot completely authenticate the remote server.","translation":"మూడవది, మీరు రిమోట్ సర్వర్‌ను పూర్తిగా ప్రామాణీకరించలేని పరిస్థితి ఉంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"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.","translation":"మీ భద్రతా విధానం మీరు విశ్వసనీయ సర్వర్‌లతో మాత్రమే మెయిల్ మార్పిడి చేయాలని నిర్దేశిస్తే, అప్పుడు ప్రమాణీకరణ లేకపోవడం స్పష్టంగా లోపం సందేశానికి హామీ ఇచ్చే సమస్య; కానీ సాధారణ ప్రయోజన క్లయింట్ కోసం, బదులుగా ఇది బహుశా హెచ్చరికకు అర్హత పొందుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"The program was ending.","translation":"ప్రోగ్రామ్ ముగుస్తోంది.","target_lang":"te","domain":"general","complexity":"simple"}
{"en":"Programs change their behavior when talking to a terminal.","translation":"టెర్మినల్‌తో మాట్లాడేటప్పుడు ప్రోగ్రామ్‌లు వాటి ప్రవర్తనను మారుస్తాయి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The Unix terminal defaults to “canonical” input processing.","translation":"యూనిక్స్ టెర్మినల్ “కెనానికల్” ఇన్పుట్ ప్రాసెసింగ్‌కు డిఫాల్ట్ అవుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"You can use the stty command to disable it.","translation":"మీరు దీన్ని నిలిపివేయడానికి stty కమాండ్ ఉపయోగించవచ్చు.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Unix terminals traditionally supported a pair of keystrokes for pausing the output stream.","translation":"యూనిక్స్ టెర్మినల్స్ సాంప్రదాయకంగా అవుట్‌పుట్ స్ట్రీమ్‌ను పాజ్ చేయడానికి కొన్ని కీస్ట్రోక్‌లను సపోర్ట్ చేస్తాయి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"This setting can be turned off with stty.","translation":"ఈ సెట్టింగ్‌ను sttyతో ఆఫ్ చేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Because there are so many settings, the stty command supports two modes.","translation":"అనేక సెట్టింగ్‌లు ఉన్నందున, stty కమాండ్ రెండు మోడ్‌లకు మద్దతు ఇస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Most Unix systems provide a command for resetting the terminal.","translation":"చాలా యూనిక్స్ సిస్టమ్‌లు టెర్మినల్‌ను రీసెట్ చేయడానికి ఒక కమాండ్‌ను అందిస్తాయి.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Check out the termios module that comes with the Standard Library.","translation":"ప్రామాణిక లైబ్రరీతో వచ్చే టెర్మియోస్ మాడ్యూల్‌ను చూడండి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Telnet is insecure.","translation":"టెల్నెట్ సురక్షితం కాదు.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Anyone watching your Telnet packets will see your username and password.","translation":"మీ టెల్నెట్ ప్యాకెట్‌లను చూసే ఎవరైనా మీ వినియోగదారు పేరు మరియు పాస్‌వర్డ్‌ను చూస్తారు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Listing 16–3 connects to localhost.","translation":"జాబితా 16–3 localhostకి కనెక్ట్ అవుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"The listing shows you the general structure of a session powered by telnetlib.","translation":"టెల్నెట్‌లిబ్ ద్వారా నడిచే సెషన్ యొక్క సాధారణ నిర్మాణాన్ని జాబితా మీకు చూపుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"You can call set_debuglevel(1) if you want your Telnet object to print out all of the strings.","translation":"మీరు మీ టెల్నెట్ ఆబ్జెక్ట్ అన్ని స్ట్రింగ్‌లను ప్రింట్ చేయాలనుకుంటే, మీరు set_debuglevel(1)ని కాల్ చేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Telnet does not disguise the fact that its service is backed by a TCP socket.","translation":"టెల్నెట్ దాని సేవ TCP సాకెట్ ద్వారా మద్దతు ఇవ్వబడుతుందనే వాస్తవాన్ని దాచదు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Interaction generally falls into a receive-and-send pattern.","translation":"పరస్పర చర్య సాధారణంగా స్వీకరించడం మరియు పంపడం నమూనాలోకి వస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The read_until() method watches for a literal string to arrive.","translation":"read_until() పద్ధతి అక్షర స్ట్రింగ్ రావడానికి చూస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The expect() method takes a list of Python regular expressions.","translation":"expect() పద్ధతి పైథాన్ రెగ్యులర్ ఎక్స్‌ప్రెషన్స్ జాబితాను తీసుకుంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Regular expressions, as always, have to be written carefully.","translation":"రెగ్యులర్ ఎక్స్‌ప్రెషన్స్, ఎల్లప్పుడూ వలె, జాగ్రత్తగా వ్రాయాలి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"If you wind up writing a Python script that has to use Telnet, it will simply be a larger or more complicated version.","translation":"మీరు టెల్నెట్‌ను ఉపయోగించాల్సిన పైథాన్ స్క్రిప్ట్‌ను వ్రాస్తే, అది కేవలం పెద్ద లేదా మరింత సంక్లిష్టమైన వెర్షన్ అవుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"The IMAPClient package is written by a friendly Python programmer named Menno Smits.","translation":"IMAPClient ప్యాకేజీని మెన్నో స్మిట్స్ అనే స్నేహపూర్వక పైథాన్ ప్రోగ్రామర్ రాశారు.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"If you want to try out IMAPClient, try installing it in a “virtualenv.”","translation":"మీరు IMAPClientని ప్రయత్నించాలనుకుంటే, దానిని “virtualenv”లో ఇన్‌స్టాల్ చేయడానికి ప్రయత్నించండి.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"You can see immediately from the code that more details of the protocol exchange are now being handled on our behalf.","translation":"ప్రోటోకాల్ మార్పిడికి సంబంధించిన మరిన్ని వివరాలు ఇప్పుడు మన తరపున నిర్వహించబడుతున్నాయని కోడ్ నుండి మీరు వెంటనే చూడవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"For example, we no longer get a status code back that we have to check every time we run a command.","translation":"ఉదాహరణకు, మనం ఇకపై ప్రతిసారీ ఒక కమాండ్ రన్ చేసినప్పుడు తనిఖీ చేయవలసిన స్టేటస్ కోడ్‌ను తిరిగి పొందలేము.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"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.","translation":"డేటా యొక్క ప్రతి లైన్ మనకు ఫోల్డర్ ఫ్లాగ్‌లు, ఫోల్డర్ పేరు డిలిమిటర్ మరియు ఫోల్డర్ పేరును అందిస్తూ ఒక టపుల్‌గా తిరిగి వస్తుంది మరియు ఫ్లాగ్‌లు స్ట్రింగ్‌ల శ్రేణి.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"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.","translation":"అంటే ఫోల్డర్‌లో సబ్-ఫోల్డర్‌లు ఏవీ లేవు మరియు భవిష్యత్తులో సబ్-ఫోల్డర్‌లను కలిగి ఉండటం సాధ్యం కాదు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"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.","translation":"అంటే ఈ ఫోల్డర్‌లో select_folder()ని అమలు చేయడం సాధ్యం కాదు—అంటే, ఈ ఫోల్డర్‌లో సందేశాలు ఉండవు మరియు కలిగి ఉండలేవు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"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.","translation":"అంటే సర్వర్ ఈ పెట్టెను ఏదో ఒక విధంగా ఆసక్తికరంగా పరిగణిస్తుంది; సాధారణంగా, చివరిసారి ఫోల్డర్‌ను ఎంచుకున్నప్పటి నుండి కొత్త సందేశాలు డెలివరీ చేయబడ్డాయని ఇది సూచిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Your code must be able to accept and ignore those additional flags.","translation":"మీ కోడ్ ఆ అదనపు ఫ్లాగ్‌లను అంగీకరించగలగాలి మరియు విస్మరించగలగాలి.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"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.","translation":"ఇది పరస్పర చర్యను మరింత ఆహ్లాదకరంగా చేస్తుంది, కానీ మీ ప్రోగ్రామ్ ఎల్లప్పుడూ ఏ ఫోల్డర్ ఎంచుకోబడిందో తెలుసుకోవడానికి జాగ్రత్తగా ఉండాలి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"When selecting, you have the option to select the folder “read only” by supplying a readonly=True argument.","translation":"ఎంచుకున్నప్పుడు, readonly=True వాదనను అందించడం ద్వారా ఫోల్డర్‌ను “రీడ్ ఓన్లీ” ఎంచుకునే అవకాశం మీకు ఉంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Message numbers are assigned right when you select the folder.","translation":"మీరు ఫోల్డర్‌ను ఎంచుకున్న వెంటనే సందేశ సంఖ్యలు కేటాయించబడతాయి.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"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.","translation":"కానీ, దీనికి విరుద్ధంగా, UID మీరు సర్వర్‌కు మీ కనెక్షన్‌ను మూసివేసినా మరియు మరొక వారం పాటు మళ్లీ కనెక్ట్ కాకపోయినా ఒకే విధంగా ఉండేలా రూపొందించబడింది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"If you are writing a synchronization tool, this behavior is quite useful!","translation":"మీరు సమకాలీకరణ సాధనాన్ని వ్రాస్తుంటే, ఈ ప్రవర్తన చాలా ఉపయోగకరంగా ఉంటుంది!","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Most IMAP commands that work with specific messages can take either message numbers or UIDs.","translation":"నిర్దిష్ట సందేశాలతో పనిచేసే చాలా IMAP ఆదేశాలు సందేశ సంఖ్యలు లేదా UIDs తీసుకోవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"When you supply a message number, you can instead supply a comma-separated list of message numbers.","translation":"మీరు సందేశ సంఖ్యను అందించినప్పుడు, మీరు కామాతో వేరు చేయబడిన సందేశ సంఖ్యల జాబితాను అందించవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"An asterisk means “and all of the rest of the messages.”","translation":"నక్షత్రం గుర్తు “మరియు మిగిలిన అన్ని సందేశాలు” అని అర్థం.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"The summary is returned by IMAPClient as a dictionary.","translation":"సారాంశం IMAPClient ద్వారా నిఘంటువుగా తిరిగి ఇవ్వబడుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Remember to compare the UIDVALIDITY to a stored value from a previous session.","translation":"మునుపటి సెషన్ నుండి నిల్వ చేసిన విలువతో UIDVALIDITYని సరిపోల్చాలని గుర్తుంచుకోండి.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"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.","translation":"ఇది చాలా సులభమైనది మరియు తక్కువ నెట్‌వర్క్ ట్రాఫిక్‌ను కలిగి ఉంటుంది, అంటే తిరిగి వచ్చిన అన్ని సందేశాలు మెమరీలో కలిసి ఉండాలి.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Once the user has selected a particular message, we use a technique that we have not discussed so far.","translation":"ఒకసారి వినియోగదారుడు ఒక నిర్దిష్ట సందేశాన్ని ఎంచుకున్న తర్వాత, మేము ఇంతకు ముందు చర్చించని ఒక పద్ధతిని ఉపయోగిస్తాము.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"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.","translation":"ఒక పెద్ద సందేశం యొక్క జోడింపులను జాబితా చేయడానికి మాత్రమే నెట్‌వర్క్ ద్వారా అనేక మెగాబైట్‌లను లాగడానికి బదులుగా, BODYSTRUCTURE దాని MIME విభాగాలను పునరావృత డేటా నిర్మాణంగా జాబితా చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Simple MIME parts are returned as a tuple: ('TEXT', 'PLAIN', ('CHARSET', 'US-ASCII'), None, None, '7BIT', 2279, 48)","translation":"సాధారణ MIME భాగాలు ఒక ట్యూపుల్‌గా తిరిగి ఇవ్వబడతాయి: ('TEXT', 'PLAIN', ('CHARSET', 'US-ASCII'), None, None, '7BIT', 2279, 48)","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"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):","translation":"RFC 3501 యొక్క విభాగం 7.4.2 లో వివరంగా ఉన్న ఈ ట్యూపుల్ యొక్క అంశాలు ఈ క్రింది విధంగా ఉన్నాయి (అంశ సూచిక సున్నా నుండి ప్రారంభించి, కోర్సులో):","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"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.","translation":"IMAP సర్వర్ ఒక సందేశం బహుళ భాగమని చూసినప్పుడు లేదా అది కనుగొన్న సందేశంలోని భాగాలలో ఒకదానిని పరిశీలించినప్పుడు అది కూడా బహుళ భాగమని, అప్పుడు అది తిరిగి ఇచ్చే ట్యూపుల్ ఉప-నిర్మాణాల జాబితాతో ప్రారంభమవుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"The value \"MIXED\" indicates exactly what kind of multipart container is being represented—in this case, the full type is multipart/mixed.","translation":"\"MIXED\" విలువ ఏ రకమైన బహుళ భాగాల కంటైనర్ సూచించబడుతుందో ఖచ్చితంగా సూచిస్తుంది - ఈ సందర్భంలో, పూర్తి రకం బహుళ భాగం/మిశ్రమంగా ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Other common “multipart” subtypes besides “mixed” are alternative, digest, and parallel.","translation":"\"మిశ్రమ\"తో పాటు ఇతర సాధారణ \"బహుళ భాగం\" ఉప రకాలు ప్రత్యామ్నాయం, డైజెస్ట్ మరియు సమాంతరంగా ఉన్నాయి.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"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.","translation":"ఈ నియమాలను బట్టి, జాబితా 15–7లో display_structure() వంటి పునరావృత దినచర్య సందేశంలోని భాగాల శ్రేణిని విప్పుటకు మరియు ప్రదర్శించడానికి ఎలా సరైనదో మీరు చూడవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"You can see that the message whose structure is shown here is a quite typical modern e-mail.","translation":"ఇక్కడ చూపబడిన నిర్మాణం కలిగిన సందేశం చాలా సాధారణ ఆధునిక ఇ-మెయిల్ అని మీరు చూడవచ్చు.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"It also contains a file attachment, complete with a suggested file name in case the user wants to download it to the local filesystem.","translation":"ఇది వినియోగదారుడు స్థానిక ఫైల్ సిస్టమ్‌కు డౌన్‌లోడ్ చేయాలనుకుంటే, సూచించిన ఫైల్ పేరుతో సహా ఫైల్ అటాచ్‌మెంట్‌ను కూడా కలిగి ఉంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Our sample program does not attempt to save anything to the hard drive, both for simplicity and safety.","translation":"సరళత మరియు భద్రత కోసం, మా నమూనా ప్రోగ్రామ్ హార్డ్ డ్రైవ్‌లో దేనినీ సేవ్ చేయడానికి ప్రయత్నించదు.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"If you examine the program listing, you will see that all of this is supported simply by calls to the IMAP fetch() method.","translation":"మీరు ప్రోగ్రామ్ జాబితాను పరిశీలిస్తే, ఇదంతా IMAP fetch() పద్ధతికి కాల్స్ ద్వారా మాత్రమే మద్దతు ఇవ్వబడుతుందని మీరు చూస్తారు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"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.","translation":"HEADER మరియు 1.1 వంటి భాగాల పేర్లు మీరు fetch()ని పిలిచినప్పుడు మీరు పేర్కొనగలిగే మరిన్ని ఎంపికలు మరియు BODY వంటి ఇతర విలువల పక్కన ఉపయోగించవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"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!","translation":"మీరు గమనించే ఒక విచిత్రం ఏమిటంటే, IMAP ప్రోటోకాల్ వాస్తవానికి ఒక నిర్దిష్ట సందేశం మద్దతు ఇచ్చే బహుళ భాగాల పేర్లలో దేనినీ మీకు అందించదు!","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"You can see that our display_structure() routine here uses a simple loop to accomplish this counting.","translation":"ఈ లెక్కింపును సాధించడానికి మా display_structure() దినచర్య ఇక్కడ ఒక సాధారణ లూప్‌ను ఉపయోగిస్తుందని మీరు చూడవచ్చు.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"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!","translation":"fetch() కమాండ్ గురించి చివరి గమనిక: ఇది మీకు ఏ క్షణంలోనైనా అవసరమైన సందేశంలోని భాగాలను మాత్రమే లాగడానికి మిమ్మల్ని అనుమతిస్తుంది, కానీ అవి చాలా పొడవుగా ఉంటే వాటిని కుదించడానికి కూడా మిమ్మల్ని అనుమతిస్తుంది మరియు మీరు వినియోగదారుని ఆకర్షించడానికి ప్రారంభం నుండి ఒక భాగాన్ని అందించాలనుకుంటే!","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"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 \textbackslash Seen for one of the messages just cited.","translation":"మీరు జాబితా 15–7ని ప్రయత్నిస్తున్నప్పుడు లేదా ఇప్పుడే చూపిన దాని ఉదాహరణ అవుట్‌పుట్‌ను చదువుతున్నప్పుడు, IMAP సందేశాలను “ఫ్లాగ్‌లు” అని పిలువబడే లక్షణాలతో గుర్తిస్తుందని మీరు గమనించి ఉండవచ్చు, ఇవి సాధారణంగా బ్యాక్‌స్లాష్-ముందున్న పదం రూపంలో ఉంటాయి, \textbackslash Seen వంటివి.ఇప్పుడే ఉదహరించిన సందేశాలలో ఒకటి.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Several of these are standard, and are defined in RFC 3501 for use on all IMAP servers.","translation":"వీటిలో కొన్ని ప్రామాణికమైనవి మరియు అన్ని IMAP సర్వర్‌లలో ఉపయోగం కోసం RFC 3501లో నిర్వచించబడ్డాయి.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"The IMAPClient library supports several methods for working with flags.","translation":"ఫ్లాగ్‌లతో పని చేయడానికి IMAPClient లైబ్రరీ అనేక పద్ధతులను సపోర్ట్ చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"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:","translation":"మీరు సరైన శ్రేణిని జోడించడం మరియు తీసివేయడం వంటివి తెలుసుకోకుండానే ఒక నిర్దిష్ట సందేశం కోసం ఫ్లాగ్‌ల సమితిని పూర్తిగా మార్చాలనుకుంటే, మీరు సందేశ ఫ్లాగ్‌ల మొత్తం జాబితాను కొత్తదానితో ఏకపక్షంగా భర్తీ చేయడానికి set_flags()ని ఉపయోగించవచ్చు:","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"But, in general, Unix has no special characters, and this is a very important fact for you to grasp.","translation":"కానీ, సాధారణంగా, యూనిక్స్ ప్రత్యేక అక్షరాలను కలిగి ఉండదు మరియు మీరు అర్థం చేసుకోవలసిన చాలా ముఖ్యమైన విషయం ఇది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"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.","translation":"మీరు బాష్ వంటి షెల్‌ను ఎక్కువ కాలం ఉపయోగించినట్లయితే, మీరు మీ సిస్టమ్‌ను చాలా శక్తివంతమైన మరియు అనుకూలమైన మైన్‌ఫీల్డ్‌గా చూడవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"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.","translation":"ఒక వైపు, ప్రస్తుత డైరెక్టరీలోని అన్ని ఫైల్‌లను కమాండ్‌కు వాదనలుగా పేరు పెట్టడం చాలా సులభం చేస్తుంది; కానీ మరోవైపు, సింగిల్ కోట్స్ మరియు డబుల్ కోట్స్‌ను మిళితం చేసే సందేశాన్ని స్క్రీన్‌కు ఎకో చేయడం చాలా కష్టం.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"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.","translation":"ఈ విభాగం యొక్క సాధారణ పాఠం ఏమిటంటే, మీరు అలవాటు పడిన మొత్తం సమావేశాలకు మీ ఆపరేటింగ్ సిస్టమ్‌తో సంబంధం లేదు; అవి బాష్ షెల్ యొక్క ప్రవర్తన లేదా మీరు ఉపయోగిస్తున్న ఇతర ప్రసిద్ధ (లేదా రహస్య) షెల్‌లలో ఏదైనా.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"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.","translation":"నిబంధనలు ఎంత సుపరిచితంగా ఉన్నాయో లేదా వాటి లేకుండా యూనిక్స్ లాంటి వ్యవస్థను ఉపయోగించడం మీకు ఎంత కష్టమో అది ముఖ్యం కాదు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"If you take bash away, they are simply not there.","translation":"మీరు బాష్‌ను తీసివేస్తే, అవి అక్కడ ఉండవు.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"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.","translation":"మీరు ఆపరేటింగ్ సిస్టమ్ యొక్క ప్రాసెస్ లాంచర్‌ను మీరే నియంత్రించడం ద్వారా మరియు కొన్ని ప్రత్యేక అక్షరాలను తెలిసిన కమాండ్‌కు విసిరేయడానికి ప్రయత్నించడం ద్వారా దీన్ని చాలా సులభంగా గమనించవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"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.","translation":"ఇక్కడ, మేము కమాండ్లను అర్థం చేసుకోవడానికి అందుబాటులో ఉన్న అన్ని షెల్ అప్లికేషన్‌లను దాటవేస్తున్నాము మరియు మేము అందించిన వాదనల జాబితాను ఖచ్చితంగా ఉపయోగించి కొత్త ప్రాసెస్‌ను ప్రారంభించమని ఆపరేటింగ్ సిస్టమ్‌కు చెబుతున్నాము.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"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.","translation":"మరియు ప్రక్రియ - ఈ సందర్భంలో ఎకో కమాండ్ - మొదట *ని ఫైల్ పేర్ల జాబితాగా మార్చడానికి బదులుగా, ఖచ్చితంగా ఆ అక్షరాలను పొందుతోంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Though we rarely think about it, the most common “special” character is one we use all the time: the space character!","translation":"మనం దాని గురించి చాలా అరుదుగా ఆలోచిస్తున్నప్పటికీ, అత్యంత సాధారణమైన “ప్రత్యేక” అక్షరం మనం ఎల్లప్పుడూ ఉపయోగించేది: స్పేస్ అక్షరం!","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"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.","translation":"మీరు వాస్తవానికి మీరు పిలుస్తున్న కమాండ్‌కు ప్రతి స్పేస్ అక్షరాన్ని పంపాలని అనుకుంటున్నారు అని అనుకోవడానికి బదులుగా, షెల్ బదులుగా మీరు కమాండ్ చూడాలనుకుంటున్న అసలు వచనాన్ని వేరుచేసే డీలిమిటర్‌గా అర్థం చేసుకుంటుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"This causes endless entertainment when people include spaces in Unix file names, and then try to move the file somewhere else.","translation":"యూనిక్స్ ఫైల్ పేర్లలో ప్రజలు స్పేస్‌లను చేర్చినప్పుడు మరియు ఫైల్‌ను మరెక్కడికైనా తరలించడానికి ప్రయత్నించినప్పుడు ఇది అంతులేని వినోదాన్ని కలిగిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"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:","translation":"మీరు దాని పేరులో స్పేస్ ఉన్న ఒక ఫైల్ గురించి మాట్లాడుతున్నారని షెల్ అర్థం చేసుకోవడానికి, రెండు ఫైల్‌లు కాదు, మీరు ఈ కమాండ్ లైన్‌లలో ఒకదానిలా ఏదైనా కల్పించాలి:","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"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.","translation":"చివరి అవకాశం స్పష్టంగా చాలా భిన్నమైన అర్థాన్నిస్తుంది - ఇది స్మిత్‌తో ప్రారంభమయ్యే మరియు కాంట్రాక్ట్.టెక్స్ట్ తో ముగిసే ఏదైనా ఫైల్ పేరుతో సరిపోలుతుంది, వాటి మధ్య వచనం సాధారణ స్పేస్ అక్షరం లేదా చాలా పొడవైన వచన క్రమం అయినా - కానీ షెల్ సమావేశాలను నేర్చుకుంటున్న మరియు షెల్ కోసం అక్షర స్పేస్ అక్షరాన్ని ఎలా టైప్ చేయాలో గుర్తుంచుకోలేని చాలా మంది ప్రజలు నిరాశతో టైప్ చేయడం నేను చూశాను.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"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.","translation":"బాష్ షెల్ మిమ్మల్ని జాగ్రత్తగా ఉండమని నేర్పించిన అక్షరాలలో ఏదీ ప్రత్యేకమైనది కాదని మీరు మిమ్మల్ని మీరు ఒప్పించాలనుకుంటే, జాబితా 16–2 ఒక సాధారణ షెల్‌ను చూపుతుంది, ఇది పైథాన్‌లో వ్రాయబడింది, ఇది స్పేస్‌ను మాత్రమే ప్రత్యేకంగా పరిగణిస్తుంది, కానీ మిగిలిన వాటిని అక్షరాలా కమాండ్‌కు పంపుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"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!","translation":"వాస్తవానికి, దీని అర్థం ఏమిటంటే, మీరు ఈ షెల్‌ను వారి పేర్లలో స్పేస్‌లతో ఉన్న ఫైల్‌ల గురించి మాట్లాడటానికి ఉపయోగించలేరు, ఎందుకంటే కనీసం మరొక ప్రత్యేక అక్షరం లేకుండా - ఎస్కేప్ లేదా కోటింగ్ అక్షరం - మీరు స్పేస్‌లను వాదన విభజనకర్త తప్ప మరేమీ అర్థం చేసుకోలేరు!","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"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):","translation":"కానీ మీరు ఎల్లప్పుడూ భయపడే అన్ని రకాల ప్రత్యేక అక్షరాలను ప్రయత్నించడానికి మీరు ఈ షెల్‌ను త్వరగా తీసుకురావచ్చు మరియు మీరు ఉపయోగించే సాధారణ కమాండ్‌లకు నేరుగా పంపితే అవి ఏమీ అర్థం కాదని చూడవచ్చు (జాబితా 16–2లోని షెల్ ] ప్రాంప్ట్‌ను ఉపయోగిస్తుంది, ఇది మీ స్వంత షెల్ నుండి వేరు చేయడం సులభం చేస్తుంది):","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"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.","translation":"యూనిక్స్ కమాండ్‌లు - ఈ సందర్భంలో, మనం పదేపదే పిలుస్తున్న /bin/echo కమాండ్ - సాధారణంగా వాటి వాదనలను స్ట్రింగ్‌లుగా కాకుండా మరేదైనా అర్థం చేసుకోవడానికి ప్రయత్నించవని మీరు ఇక్కడ ఖచ్చితమైన రుజువును చూడవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The echo command happily accepts double-quotes, dollar signs, and asterisks, and treats them all as literal characters.","translation":"ఎకో కమాండ్ సంతోషంగా డబుల్ కోట్స్, డాలర్ గుర్తులు మరియు నక్షత్రాలను అంగీకరిస్తుంది మరియు వాటిని అక్షర అక్షరాలుగా పరిగణిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"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.","translation":"ముందుగా చూపిన కమాండ్ వివరించినట్లుగా, పైథాన్ కేవలం కొత్త ప్రాసెస్‌ను సృష్టించడంలో ఉపయోగించడానికి మా వాదనలను స్ట్రింగ్‌ల జాబితాకు తగ్గిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"You simply provide them in your call to the connect() method.","translation":"మీరు వాటిని కనెక్ట్() పద్ధతికి కాల్ చేసినప్పుడు అందిస్తారు.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Public-key authentication makes the Python code even easier!","translation":"పబ్లిక్-కీ ప్రమాణీకరణ పైథాన్ కోడ్‌ను మరింత సులభతరం చేస్తుంది!","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"If your identity key file is stored somewhere other than in the normal ~/.ssh/id_rsa file, then you can provide its file name.","translation":"మీ గుర్తింపు కీ ఫైల్ సాధారణ ~/.ssh/id_rsa ఫైల్ కాకుండా మరెక్కడైనా నిల్వ చేయబడితే, మీరు దాని ఫైల్ పేరును అందించవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"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.","translation":"వాస్తవానికి, SSH యొక్క సాధారణ నియమాల ప్రకారం, ఇలాంటి పబ్లిక్-కీ గుర్తింపును అందించడం, మీరు id_sysadmin.pub ఫైల్‌లోని పబ్లిక్ కీని మీ “అధికారిక హోస్ట్‌లు” ఫైల్‌కు జోడిస్తేనే పని చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"If you have trouble getting public-key authentication to work, always check the file permissions.","translation":"పబ్లిక్-కీ ప్రమాణీకరణ పని చేయడంలో మీకు సమస్య ఉంటే, ఎల్లప్పుడూ ఫైల్ అనుమతులను తనిఖీ చేయండి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The task of copying SSH keys to other accounts has actually been automated in recent versions.","translation":"SSH కీలను ఇతర ఖాతాలకు కాపీ చేసే పని వాస్తవానికి ఇటీవలి వెర్షన్‌లలో స్వయంచాలకంగా చేయబడింది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Once the connect() method has succeeded, you are now ready to start performing remote operations.","translation":"కనెక్ట్() పద్ధతి విజయవంతమైన తర్వాత, మీరు ఇప్పుడు రిమోట్ కార్యకలాపాలను ప్రారంభించడానికి సిద్ధంగా ఉన్నారు.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Simply by asking, you can access remote-shell sessions, run individual commands, commence file-transfer sessions, and set up port forwarding.","translation":"అడగడం ద్వారా, మీరు రిమోట్-షెల్ సెషన్‌లను యాక్సెస్ చేయవచ్చు, వ్యక్తిగత ఆదేశాలను అమలు చేయవచ్చు, ఫైల్-ట్రాన్స్‌ఫర్ సెషన్‌లను ప్రారంభించవచ్చు మరియు పోర్ట్ ఫార్వార్డింగ్‌ను సెటప్ చేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"First, SSH can set up a raw shell session for you.","translation":"ముందుగా, SSH మీ కోసం ఒక ముడి షెల్ సెషన్‌ను ఏర్పాటు చేయగలదు.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"This kind of connection behaves very much like a Telnet connection.","translation":"ఈ రకమైన కనెక్షన్ టెల్నెట్ కనెక్షన్ లాగానే ప్రవర్తిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"A much better option for running remote commands is to use exec_command().","translation":"రిమోట్ ఆదేశాలను అమలు చేయడానికి చాలా మంచి ఎంపిక exec_command()ని ఉపయోగించడం.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"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.","translation":"exec_command() మరియు స్థానిక ఉప ప్రక్రియ మధ్య వ్యత్యాసం ఏమిటంటే, మీరు కమాండ్-లైన్ వాదనలను ప్రత్యేక స్ట్రింగ్‌లుగా పాస్ చేయడానికి అవకాశం పొందలేరు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"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.","translation":"మీరు invoke_shell()తో కొత్త SSH షెల్ సెషన్‌ను ప్రారంభించిన ప్రతిసారీ మరియు మీరు exec_command()తో ఒక ఆదేశాన్ని ప్రారంభించిన ప్రతిసారీ, తెర వెనుక ఒక కొత్త SSH “ఛానెల్” సృష్టించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Channels, as just explained, can run in parallel, and SSH will cleverly interleave their data on your single SSH connection.","translation":"ఛానెల్‌లు, ఇప్పుడే వివరించినట్లుగా, సమాంతరంగా అమలు చేయబడతాయి మరియు SSH మీ సింగిల్ SSH కనెక్షన్‌లో వాటి డేటాను తెలివిగా మిళితం చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"SFTP: File Transfer Over SSH","translation":"SFTP: SSH ద్వారా ఫైల్ బదిలీ","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"The SFTP protocol is an incredible boon.","translation":"SFTP ప్రోటోకాల్ ఒక అద్భుతమైన వరం.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"The SFTP protocol is stateful, just like FTP.","translation":"SFTP ప్రోటోకాల్ FTP లాగానే స్టేట్‌ఫుల్.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"You can open a file using either the file() or open() method.","translation":"మీరు file() లేదా open() పద్ధతిని ఉపయోగించి ఒక ఫైల్‌ను తెరవవచ్చు.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Be careful that you recognize this, or you might open so many channels at once that each one slows to a crawl.","translation":"దీన్ని మీరు గుర్తించాలని జాగ్రత్త వహించండి, లేకపోతే మీరు ఒకేసారి చాలా ఛానెల్‌లను తెరవవచ్చు, తద్వారా ప్రతి ఒక్కటి నెమ్మదిగా కదలడం ప్రారంభిస్తాయి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"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.","translation":"మీరు * వంటి ఫైల్ పేరును లేదా ఖాళీలు లేదా ప్రత్యేక అక్షరాలు ఉన్నదాన్ని ఉపయోగించడానికి ప్రయత్నిస్తే, అవి ఫైల్ పేరులో భాగంగానే అర్థం చేసుకోబడతాయి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"A much better alternative today is for service providers to support SFTP instead.","translation":"సేవా ప్రదాతలు SFTPకి మద్దతు ఇవ్వడం ఈ రోజుల్లో చాలా మంచి ప్రత్యామ్నాయం.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The FTP standard is RFC959, available at http://www.faqs.org/rfcs/rfc959.html.","translation":"FTP ప్రమాణం RFC959, ఇది http://www.faqs.org/rfcs/rfc959.html వద్ద అందుబాటులో ఉంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"One connection is the control channel, which carries commands and the resulting acknowledgments or error codes.","translation":"ఒక కనెక్షన్ నియంత్రణ ఛానెల్, ఇది ఆదేశాలను మరియు ఫలితంగా వచ్చే అంగీకారాలు లేదా లోపం కోడ్‌లను కలిగి ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The second connection is the data channel, which is used solely for transmitting file data.","translation":"రెండవ కనెక్షన్ డేటా ఛానెల్, ఇది ఫైల్ డేటాను ప్రసారం చేయడానికి మాత్రమే ఉపయోగించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"However, in actual practice, this capability is rarely used.","translation":"అయితే, వాస్తవానికి, ఈ సామర్థ్యం చాలా అరుదుగా ఉపయోగించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"First, the FTP client establishes a command connection by connecting to the FTP port on the server.","translation":"ముందుగా, FTP క్లయింట్ సర్వర్ లోని FTP పోర్ట్‌కు కనెక్ట్ చేయడం ద్వారా కమాండ్ కనెక్షన్‌ను ఏర్పాటు చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The client authenticates itself, usually with username and password.","translation":"క్లయింట్ సాధారణంగా వినియోగదారు పేరు మరియు పాస్‌వర్డ్‌తో తనను తాను ప్రమాణీకరిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"The client changes directory on the server to where it wants to deposit or retrieve files.","translation":"ఫైల్‌లను డిపాజిట్ చేయడానికి లేదా తిరిగి పొందడానికి క్లయింట్ సర్వర్ లోని డైరెక్టరీని మారుస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The client begins listening on a new port for the data connection, and then informs the server about that port.","translation":"డేటా కనెక్షన్ కోసం క్లయింట్ కొత్త పోర్ట్‌ను వినడం ప్రారంభిస్తుంది, ఆపై ఆ పోర్ట్ గురించి సర్వర్‌కు తెలియజేస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The server connects to the port the client requested.","translation":"క్లయింట్ అభ్యర్థించిన పోర్ట్‌కు సర్వర్ కనెక్ట్ అవుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"This worked well in the early days of the Internet; back then, most every machine that could run FTP had a public IP address.","translation":"ఇంటర్నెట్ ప్రారంభ రోజుల్లో ఇది బాగా పనిచేసింది; అప్పట్లో, FTPని అమలు చేయగల దాదాపు ప్రతి యంత్రానికి పబ్లిక్ IP చిరునామా ఉండేది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Firewalls blocking incoming connections to desktop and laptop machines are now quite common.","translation":"డెస్క్‌టాప్ మరియు ల్యాప్‌టాప్ యంత్రాలకు వచ్చే కనెక్షన్‌లను నిరోధించే ఫైర్‌వాల్‌లు ఇప్పుడు చాలా సాధారణం.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"To accommodate this situation, FTP also supports what is known as passive mode.","translation":"ఈ పరిస్థితిని పరిష్కరించడానికి, FTP నిష్క్రియ మోడ్‌గా పిలువబడే వాటికి కూడా మద్దతు ఇస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Passive mode is today the default with most FTP clients, as well as Python’s ftplib module.","translation":"నిష్క్రియ మోడ్ ఈ రోజు చాలా FTP క్లయింట్‌లతో పాటు పైథాన్ యొక్క ftplib మాడ్యూల్‌తో డిఫాల్ట్‌గా ఉంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The Python module ftplib is the primary interface to FTP for Python programmers.","translation":"పైథాన్ ప్రోగ్రామర్‌ల కోసం FTPకి ftplib మాడ్యూల్ ప్రధాన ఇంటర్‌ఫేస్.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"It handles the details of establishing the various connections for you, and provides convenient ways to automate common commands.","translation":"ఇది మీ కోసం వివిధ కనెక్షన్‌లను ఏర్పాటు చేసే వివరాలను నిర్వహిస్తుంది మరియు సాధారణ ఆదేశాలను స్వయంచాలకంగా చేయడానికి అనుకూలమైన మార్గాలను అందిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"If you are interested only in downloading files, the urllib2 module introduced in Chapter 1 supports FTP.","translation":"మీరు ఫైల్‌లను డౌన్‌లోడ్ చేయడంలో మాత్రమే ఆసక్తి కలిగి ఉంటే, అధ్యాయం 1లో ప్రవేశపెట్టిన urllib2 మాడ్యూల్ FTPకి మద్దతు ఇస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Listing 17–1 shows a very basic ftplib example.","translation":"జాబితా 17–1 చాలా ప్రాథమిక ftplib ఉదాహరణను చూపుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"The welcome message will generally have no information that could be usefully parsed by your program.","translation":"స్వాగత సందేశంలో సాధారణంగా మీ ప్రోగ్రామ్ ద్వారా ఉపయోగకరంగా విశ్లేషించగల సమాచారం ఉండదు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The login() function can take several parameters, including a username, password, and a third, rarely used authentication token that FTP calls an “account.”","translation":"లాగిన్() ఫంక్షన్ వినియోగదారు పేరు, పాస్‌వర్డ్ మరియు FTP “ఖాతా” అని పిలిచే మూడవ, అరుదుగా ఉపయోగించే ప్రమాణీకరణ టోకెన్తో సహా అనేక పారామితులను తీసుకోవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"The retrlines() function is used to download a file in ASCII mode.","translation":"retrlines() ఫంక్షన్ ASCII మోడ్‌లో ఫైల్‌ను డౌన్‌లోడ్ చేయడానికి ఉపయోగించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"You can also upload files to a remote server.","translation":"మీరు రిమోట్ సర్వర్‌కు ఫైల్‌లను కూడా అప్‌లోడ్ చేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"The storlines() function uploads a file in ASCII mode.","translation":"storlines() ఫంక్షన్ ASCII మోడ్‌లో ఫైల్‌ను అప్‌లోడ్ చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"The ntransfercmd() function can be used for binary uploads and downloads.","translation":"ntransfercmd() ఫంక్షన్ బైనరీ అప్‌లోడ్‌లు మరియు డౌన్‌లోడ్‌ల కోసం ఉపయోగించవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"It gives you more control over the transfer process and is often used to support a progress bar for the user.","translation":"ఇది బదిలీ ప్రక్రియపై మీకు ఎక్కువ నియంత్రణను ఇస్తుంది మరియు సాధారణంగా వినియోగదారు కోసం ప్రోగ్రెస్ బార్‌ను అందించడానికి ఉపయోగిస్తారు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The ftplib module raises exceptions on errors.","translation":"ftplib మాడ్యూల్ లోపాలు సంభవించినప్పుడు మినహాయింపులను పెంచుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"You can use cwd() to change to a particular directory on the remote end.","translation":"మీరు రిమోట్ ఎండ్‌లో నిర్దిష్ట డైరెక్టరీకి మారడానికి cwd()ని ఉపయోగించవచ్చు.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"The nlst() command returns a simple list of all entries in a given directory.","translation":"nlst() కమాండ్ ఇచ్చిన డైరెక్టరీలోని అన్ని ఎంట్రీల యొక్క సాధారణ జాబితాను అందిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The dir() command returns a more detailed list but in server-specific format.","translation":"dir() కమాండ్ మరింత వివరణాత్మక జాబితాను అందిస్తుంది, కానీ సర్వర్-నిర్దిష్ట ఆకృతిలో.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Even with only nlst(), you can usually detect whether an entry is a file or directory.","translation":"nlst()తో కూడా, ఒక ఎంట్రీ ఫైల్ లేదా డైరెక్టరీనా అని మీరు సాధారణంగా గుర్తించవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"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.","translation":"అన్నింటికంటే, ఇక్కడ మనం మాట్లాడుకుంటున్న ఎంపికలు — మీరు డేటా ఫార్మాట్‌ను ఎంచుకోవాలి, అభ్యర్థనను పంపాలి మరియు ప్రతిస్పందనను తిరిగి పొందాలి — విధాన కాల్‌లకు ప్రత్యేకమైనవి కావు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"First, an RPC protocol is distinguished by lacking strong semantics for the meaning of each call.","translation":"మొదట, RPC ప్రోటోకాల్ ప్రతి కాల్ యొక్క అర్థానికి బలమైన అర్థశాస్త్రం లేకపోవడం ద్వారా గుర్తించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"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.","translation":"HTTP పత్రాలను తిరిగి పొందడానికి ఉపయోగించబడుతుంది మరియు SMTP సందేశాల డెలివరీకి మద్దతు ఇస్తుంది, అయితే RPC ప్రోటోకాల్ పూర్ణాంకాలు, ఫ్లోట్‌లు, స్ట్రింగ్‌లు మరియు జాబితాలు వంటి ప్రాథమిక డేటా రకాలను మద్దతు ఇవ్వడం తప్ప, పంపిన డేటాకు ఎటువంటి అర్థాన్ని కేటాయించదు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"It is instead up to each particular API that you fashion using an RPC protocol to define what its calls mean.","translation":"బదులుగా, దాని కాల్‌లు ఏమిటో నిర్వచించడానికి RPC ప్రోటోకాల్‌ను ఉపయోగించి మీరు రూపొందించే ప్రతి నిర్దిష్ట APIపై ఆధారపడి ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Second, RPC mechanisms are a way to invoke methods, but they do not define them.","translation":"రెండవది, RPC విధానాలు పద్ధతులను పిలిచే ఒక మార్గం, కానీ అవి వాటిని నిర్వచించవు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"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.","translation":"మీరు HTTP లేదా SMTP వంటి మరింత సింగిల్-పర్పస్ ప్రోటోకాల్ యొక్క స్పెసిఫికేషన్‌ను చదివినప్పుడు, అవి పరిమిత సంఖ్యలో ప్రాథమిక కార్యకలాపాలను నిర్వచిస్తాయని మీరు గమనించవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"First, every RPC mechanism has limits on the kind of data you can pass.","translation":"మొదట, ప్రతి RPC విధానం మీరు పంపగల డేటా రకంపై పరిమితులను కలిగి ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The most general-purpose RPC mechanisms tend to be the most restrictive because they are designed to work with many different programming languages.","translation":"అత్యంత సాధారణ-ప్రయోజన RPC విధానాలు చాలా పరిమితంగా ఉంటాయి, ఎందుకంటే అవి అనేక విభిన్న ప్రోగ్రామింగ్ భాషలతో పని చేయడానికి రూపొందించబడ్డాయి.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Many Python programmers are disappointed to learn that only positional arguments are typically supported.","translation":"స్థానపరమైన వాదనలు మాత్రమే సాధారణంగా మద్దతు ఇవ్వబడతాయని తెలుసుకోవడానికి చాలా మంది పైథాన్ ప్రోగ్రామర్లు నిరాశ చెందుతారు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"A second common feature is the ability of the server to signal that an exception occurred while it was running the remote function.","translation":"రెండవ సాధారణ లక్షణం ఏమిటంటే, రిమోట్ ఫంక్షన్‌ను అమలు చేస్తున్నప్పుడు ఒక మినహాయింపు సంభవించిందని సర్వర్ సిగ్నల్ చేసే సామర్థ్యం.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"The book provides a comprehensive guide to building network applications with Python.","translation":"ఈ పుస్తకం పైథాన్‌తో నెట్‌వర్క్ అప్లికేషన్‌లను రూపొందించడానికి ఒక సమగ్ర మార్గదర్శిని అందిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"UDP is a connectionless protocol.","translation":"UDP ఒక కనెక్షన్ లేని ప్రోటోకాల్.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"The index provides a detailed listing of all the terms used in the book.","translation":"సూచిక పుస్తకంలో ఉపయోగించిన అన్ని పదాల యొక్క వివరణాత్మక జాబితాను అందిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Email authentication is crucial for preventing spam.","translation":"స్పామ్‌ను నిరోధించడానికి ఇమెయిల్ ప్రమాణీకరణ చాలా ముఖ్యం.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The command-line interface offers powerful tools for automation.","translation":"కమాండ్-లైన్ ఇంటర్‌ఫేస్ ఆటోమేషన్ కోసం శక్తివంతమైన సాధనాలను అందిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Understanding DNS is essential for network programming.","translation":"నెట్‌వర్క్ ప్రోగ్రామింగ్ కోసం DNSని అర్థం చేసుకోవడం చాలా అవసరం.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"HTTP is the foundation of the World Wide Web.","translation":"HTTP వరల్డ్ వైడ్ వెబ్ యొక్క ఆధారం.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Cookies are used to store user session information.","translation":"వినియోగదారు సెషన్ సమాచారాన్ని నిల్వ చేయడానికి కుకీలను ఉపయోగిస్తారు.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"The book covers various aspects of web server frameworks.","translation":"ఈ పుస్తకం వెబ్ సర్వర్ ఫ్రేమ్‌వర్క్‌ల యొక్క వివిధ అంశాలను వివరిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"File transfer protocol (FTP) is used for transferring files.","translation":"ఫైల్‌లను బదిలీ చేయడానికి ఫైల్ ట్రాన్స్‌ఫర్ ప్రోటోకాల్ (FTP) ఉపయోగించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"The author explains the concepts of concurrent programming.","translation":"రచయిత ఏకకాలిక ప్రోగ్రామింగ్ భావనలను వివరిస్తాడు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The book delves into the details of email protocols like SMTP and IMAP.","translation":"ఈ పుస్తకం SMTP మరియు IMAP వంటి ఇమెయిల్ ప్రోటోకాల్‌ల వివరాలను వివరిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"The use of HTTPS ensures secure communication.","translation":"HTTPSని ఉపయోగించడం సురక్షితమైన కమ్యూనికేషన్‌ను నిర్ధారిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"The book provides examples of screen scraping techniques.","translation":"ఈ పుస్తకం స్క్రీన్ స్క్రాపింగ్ పద్ధతుల ఉదాహరణలను అందిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The book discusses the importance of data abstraction.","translation":"డేటా అబ్‌స్ట్రాక్షన్ యొక్క ప్రాముఖ్యతను ఈ పుస్తకం చర్చిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The book explains the concept of event-driven servers.","translation":"ఈ పుస్తకం ఈవెంట్-డ్రివెన్ సర్వర్ల భావనను వివరిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The book covers the basics of command-line editing.","translation":"ఈ పుస్తకం కమాండ్-లైన్ ఎడిటింగ్ యొక్క ప్రాథమిక అంశాలను వివరిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"The book explores the use of threading in Python.","translation":"ఈ పుస్తకం పైథాన్‌లో థ్రెడింగ్‌ను ఎలా ఉపయోగించాలో వివరిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The book provides information on the use of caching.","translation":"ఈ పుస్తకం కాషింగ్ వాడకం గురించి సమాచారాన్ని అందిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"The book discusses the use of XML-RPC for remote procedure calls.","translation":"రిమోట్ విధాన కాల్‌ల కోసం XML-RPCని ఎలా ఉపయోగించాలో ఈ పుస్తకం చర్చిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"If you need to transmit this dictionary over an RPC mechanism, your first instinct might be to change the numbers to strings.","translation":"మీరు ఈ నిఘంటువును RPC విధానం ద్వారా ప్రసారం చేయవలసి వస్తే, మీ మొదటి ఆలోచన సంఖ్యలను స్ట్రింగ్‌లుగా మార్చడం కావచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Simply put, the struct and object RPC data structures are not designed to pair keys with values in containers of an arbitrary size.","translation":"సులభంగా చెప్పాలంటే, struct మరియు object RPC డేటా నిర్మాణాలు కీలను యాదృచ్ఛిక పరిమాణంలోని కంటైనర్‌లలోని విలువలతో జత చేయడానికి రూపొందించబడలేదు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"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.","translation":"బదులుగా, అవి కొన్ని నిర్దిష్ట వస్తువు కోసం తీసుకువెళ్ళే లక్షణ విలువలతో ప్రీ-డిఫైన్ చేయబడిన లక్షణాల పేర్ల చిన్న సమితిని అనుబంధించడానికి రూపొందించబడ్డాయి.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"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.","translation":"మీరు యాదృచ్ఛిక కీలు మరియు విలువలను జత చేయడానికి structని ఉపయోగించడానికి ప్రయత్నిస్తే, స్టాటిక్‌గా టైప్ చేయబడిన ప్రోగ్రామింగ్ భాషలను ఉపయోగిస్తున్న దురదృష్టవంతులైన వ్యక్తులకు దీన్ని ఉపయోగించడం చాలా కష్టతరం చేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Instead, you should think of dictionaries being sent across RPCs as being like the __dict__ attributes of your Python objects.","translation":"బదులుగా, RPCల ద్వారా పంపబడుతున్న నిఘంటువులను మీ పైథాన్ వస్తువుల __dict__ లక్షణాల వలె పరిగణించాలి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"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.","translation":"మీ పైథాన్ వస్తువులకు మీ కోడ్‌కు బాగా తెలిసిన లక్షణాల పేర్ల చిన్న సేకరణ ఉన్నట్లే, మీరు RPC ద్వారా పంపే నిఘంటువులు కొన్ని ముందుగా నిర్వచించిన కీలను వాటి సంబంధిత విలువలతో అనుబంధించాలి.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"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.","translation":"ఇదంతా అర్థం ఏమిటంటే, నేను కొద్ది క్షణాల క్రితం చూపించిన నిఘంటువును సాధారణ-ప్రయోజన RPC విధానం ద్వారా ఉపయోగించబోతున్నట్లయితే, స్పష్టంగా లేబుల్ చేయబడిన విలువల జాబితాగా సీరియలైజ్ చేయాలి.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"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.","translation":"ఈ విధానంలో ముఖ్యమైన వ్యత్యాసం (ఈ నిఘంటువు భయంకరంగా పొడవుగా ఉందనే వాస్తవం కాకుండా) ఏమిటంటే, మీరు ముందుగానే కీలు మరియు విలువలు ఏమిటో తెలియనంత వరకు మునుపటి డేటా నిర్మాణం అర్థరహితంగా ఉంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"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.","translation":"కానీ ఇక్కడ మేము డేటాతో పేర్లను చేర్చుతున్నాము మరియు ఇది ఈ ఉదాహరణను కొంతవరకు స్వీయ-వివరణాత్మకంగా చేస్తుంది; అంటే, వైర్‌లో లేదా అతని ప్రోగ్రామ్‌లో ఈ డేటాను చూసే ఎవరైనా ఇది దేనిని సూచిస్తుందో ఊహించే అవకాశం ఉంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"I will not argue that this is always a good idea.","translation":"ఇది ఎల్లప్పుడూ మంచి ఆలోచన అని నేను వాదించను.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"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:","translation":"మీరు ఇక్కడ చర్చిస్తున్న దానిలాంటి పైథాన్ నిఘంటువును కలిగి ఉంటే, మీరు దానిని RPC- తగిన డేటా స్ట్రక్చర్‌గా మార్చవచ్చు, ఆపై ఇలాంటి కోడ్‌తో తిరిగి మార్చవచ్చు:","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Talking About Objects: Pyro and RPyC","translation":"వస్తువుల గురించి మాట్లాడుకోవడం: పైరో మరియు RPyC","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"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.","translation":"RPC యొక్క ఆలోచన రిమోట్ ఫంక్షన్ కాల్‌లను స్థానిక కాల్‌లుగా కనిపించేలా చేయడానికి ఉద్దేశించబడితే, మనం చూసిన రెండు ప్రాథమిక RPC విధానాలు వాస్తవానికి చాలా అద్భుతంగా విఫలమవుతాయి.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"What happens when you need to pass live objects?","translation":"మీరు లైవ్ ఆబ్జెక్ట్‌లను పాస్ చేయవలసి వస్తే ఏమి జరుగుతుంది?","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"This is generally a very hard problem to solve for two reasons.","translation":"ఇది సాధారణంగా రెండు కారణాల వల్ల పరిష్కరించడానికి చాలా కష్టమైన సమస్య.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"First, objects have different behaviors and semantics in different programming languages.","translation":"ముందుగా, వివిధ ప్రోగ్రామింగ్ భాషలలో వస్తువులకు విభిన్న ప్రవర్తనలు మరియు అర్థశాస్త్రం ఉంటాయి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Second, it is often not clear how much state needs to travel with an object to make it useful on another computer.","translation":"రెండవది, మరొక కంప్యూటర్‌లో ఉపయోగకరంగా ఉండటానికి ఒక వస్తువుతో ఎంత స్థితి ప్రయాణించాలో తరచుగా స్పష్టంగా ఉండదు.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"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.","translation":"అయితే, రెండు పథకాలు తరచుగా ఖరీదైన మరియు నెమ్మదిగా నడిచే ఫలితాలను ఇస్తాయి, మరియు ఒక వస్తువు నెట్‌వర్క్ యొక్క మరొక చివరన ఉన్న మరొక సర్వీస్ అందించిన సమాధానాలను ఎలా ప్రభావితం చేస్తుందో ట్రాక్ చేయడం చాలా కష్టతరం చేస్తాయి.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"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.","translation":"వాస్తవానికి, XML-RPC మరియు JSON-RPC మీపై బలవంతంగా విధించే పని - మీరు రిమోట్ సర్వీస్‌ను అడగాలనుకుంటున్న ప్రశ్నను విచ్ఛిన్నం చేసే పని, తద్వారా సాధారణ డేటా రకాలను సులభంగా ప్రసారం చేయవచ్చు - తరచుగా, కేవలం, సాఫ్ట్‌వేర్ ఆర్కిటెక్చర్ యొక్క పనిగా ముగుస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"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.","translation":"అందువల్ల, మీ రిమోట్ సర్వీస్‌లను రూపొందించకుండా మరియు వాటి పనిని చేయడానికి వారికి ఖచ్చితంగా ఏ డేటా అవసరమో తెలుసుకోవడానికి, మరింత వస్తువు-ఆధారిత RPC సేవకు వెళ్లవద్దని నేను సిఫార్సు చేస్తున్నాను.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"The book provides a comprehensive guide to building network applications with Python.","translation":"పుస్తకం పైథాన్‌తో నెట్‌వర్క్ అప్లికేషన్‌లను రూపొందించడానికి ఒక సమగ్ర మార్గదర్శిని అందిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Sockets are fundamental for network communication.","translation":"నెట్‌వర్క్ కమ్యూనికేషన్ కోసం సాకెట్‌లు చాలా ముఖ్యమైనవి.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"TCP is a reliable protocol, ensuring data delivery.","translation":"TCP ఒక నమ్మదగిన ప్రోటోకాల్, ఇది డేటా డెలివరీని నిర్ధారిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Understanding the basics of UDP is crucial for certain applications.","translation":"కొన్ని నిర్దిష్ట అనువర్తనాల కోసం UDP యొక్క ప్రాథమికాలను అర్థం చేసుకోవడం చాలా అవసరం.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The example uses the socket() function to create a socket.","translation":"ఉదాహరణ సాకెట్ను సృష్టించడానికి socket() ఫంక్షన్‌ను ఉపయోగిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"Error handling is essential when working with network programming.","translation":"నెట్‌వర్క్ ప్రోగ్రామింగ్‌తో పని చేస్తున్నప్పుడు ఎర్రర్ హ్యాండ్లింగ్ చాలా అవసరం.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The server listens for incoming connections on a specific port.","translation":"సర్వర్ ఒక నిర్దిష్ట పోర్ట్‌లో ఇన్‌కమింగ్ కనెక్షన్‌ల కోసం వింటుంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"This code demonstrates a simple client-server interaction.","translation":"ఈ కోడ్ ఒక సాధారణ క్లయింట్-సర్వర్ పరస్పర చర్యను ప్రదర్శిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"The book covers topics like threading and multi-processing.","translation":"పుస్తకం థ్రెడింగ్ మరియు మల్టీ-ప్రాసెసింగ్ వంటి అంశాలను కవర్ చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Using SSL/TLS is important for secure communication.","translation":"సురక్షిత కమ్యూనికేషన్ కోసం SSL/TLSని ఉపయోగించడం చాలా ముఖ్యం.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The example shows how to send email using SMTP.","translation":"SMTPని ఉపయోగించి ఇమెయిల్ ఎలా పంపాలో ఉదాహరణ చూపిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Web frameworks simplify web application development.","translation":"వెబ్ ఫ్రేమ్‌వర్క్‌లు వెబ్ అప్లికేషన్ అభివృద్ధిని సులభతరం చేస్తాయి.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"Understanding HTTP requests and responses is crucial.","translation":"HTTP అభ్యర్థనలు మరియు ప్రతిస్పందనలను అర్థం చేసుకోవడం చాలా ముఖ్యం.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The book also discusses XML-RPC for remote procedure calls.","translation":"రిమోట్ విధాన కాల్‌ల కోసం XML-RPC గురించి కూడా పుస్తకం చర్చిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"}
{"en":"Properly handling file descriptors is important for efficiency.","translation":"సమర్థత కోసం ఫైల్ డిస్క్రిప్టర్‌లను సరిగ్గా నిర్వహించడం చాలా ముఖ్యం.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The use of SSH for secure shell access is explained.","translation":"సురక్షిత షెల్ యాక్సెస్ కోసం SSH వినియోగం వివరించబడింది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The book provides examples of using the telnetlib module.","translation":"టెల్నెట్‌లిబ్ మాడ్యూల్‌ను ఉపయోగించడం యొక్క ఉదాహరణలను పుస్తకం అందిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"}
{"en":"The index provides a quick reference to various topics.","translation":"సూచిక వివిధ అంశాలకు శీఘ్ర సూచనను అందిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"The book is a valuable resource for network programmers.","translation":"పుస్తకం నెట్‌వర్క్ ప్రోగ్రామర్‌లకు విలువైన వనరు.","target_lang":"te","domain":"technical","complexity":"simple"}
{"en":"This comprehensive guide covers a wide range of network programming concepts.","translation":"ఈ సమగ్ర మార్గదర్శిని విస్తృత శ్రేణి నెట్‌వర్క్ ప్రోగ్రామింగ్ భావనలను కవర్ చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"}