పైథాన్ మరియు బాష్ స్నేహం చేయడం: స్మార్ట్-ఎన్వి మరియు పైథాన్-షెల్ లైబ్రరీలు

అందరికీ శుభదినం.

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

డెవొప్‌ల కోసం జీవితాన్ని సులభతరం చేయడానికి, పైథాన్‌లో అనేక ఉపయోగకరమైన లైబ్రరీలు మరియు యుటిలిటీలు సృష్టించబడ్డాయి మరియు సృష్టించబడటం కొనసాగుతుంది. ఈ వ్యాసం ఈ పోస్ట్ రచయిత సృష్టించిన రెండు కొత్త లైబ్రరీలను వివరిస్తుంది - స్మార్ట్-env и పైథాన్-షెల్ - మరియు పైథాన్‌తో పని చేసే చిక్కులపై చాలా శ్రద్ధ వహించాల్సిన అవసరం నుండి డెవొప్‌లను ఉపశమనం చేయడానికి రూపొందించబడింది, మరింత ఆసక్తికరమైన పనుల కోసం గదిని వదిలివేస్తుంది. లైబ్రరీల కార్యకలాపాల పరిధి పర్యావరణ వేరియబుల్స్ మరియు బాహ్య వినియోగాలను ప్రారంభించడం.

ఆసక్తి ఉన్నవారు, దయచేసి పిల్లిని చూడండి.

కొత్త "సైకిళ్ళు"?

చాలా సాధారణ కార్యకలాపాల కోసం కొత్త ప్యాకేజీలను ఎందుకు సృష్టించాలి? os.environ మరియు subprocess.<పద్ధతి లేదా మీకు నచ్చిన తరగతి> నేరుగా ఉపయోగించకుండా మిమ్మల్ని ఏది నిరోధిస్తుంది?

నేను ప్రతి లైబ్రరీకి అనుకూలంగా ఆధారాలను విడిగా అందిస్తాను.

స్మార్ట్-ఎన్వి లైబ్రరీ

మీ స్వంత మెదడును వ్రాయడానికి ముందు, ఆన్‌లైన్‌కి వెళ్లి రెడీమేడ్ పరిష్కారాల కోసం వెతకడం ఉపయోగకరంగా ఉంటుంది. వాస్తవానికి, మీకు అవసరమైన వాటిని కనుగొనలేని ప్రమాదం ఉంది, కానీ ఇది "భీమా ఈవెంట్". నియమం ప్రకారం, ఈ విధానం పని చేస్తుంది మరియు చాలా సమయం మరియు కృషిని ఆదా చేస్తుంది.

ఫలితాల ప్రకారం శోధన కిందిది వెల్లడైంది:

• వాస్తవానికి os.environకు కాల్‌లను చుట్టే ప్యాకేజీలు ఉన్నాయి, కానీ అదే సమయంలో అపసవ్య చర్యల సమూహం అవసరం (తరగతి యొక్క ఉదాహరణను సృష్టించడం, కాల్‌లలో ప్రత్యేక పారామితులు మొదలైనవి);
• మంచి ప్యాకేజీలు ఉన్నాయి, అయితే, నిర్దిష్ట పర్యావరణ వ్యవస్థతో (ప్రధానంగా జాంగో వంటి వెబ్ ఫ్రేమ్‌వర్క్‌లు) ఖచ్చితంగా ముడిపడి ఉంటాయి మరియు ఫైల్ లేకుండా సార్వత్రికమైనవి కావు;
• కొత్తగా ఏదైనా చేయాలనే ప్రయత్నాలు చాలా అరుదు. ఉదాహరణకి, టైపింగ్ జోడించండి మరియు వంటి పద్ధతులను కాల్ చేయడం ద్వారా వేరియబుల్ విలువలను స్పష్టంగా అన్వయించండి

  get_<typename>(var_name)

  లేదా ఇక్కడ మరొక పరిష్కారం, అయితే, ఇది ఇప్పుడు అవమానకరమైన పైథాన్ 2కి మద్దతు ఇవ్వదు (అది ఉన్నప్పటికీ అధికారిక RIP, ఇప్పటికీ లిఖిత కోడ్ మరియు మొత్తం పర్యావరణ వ్యవస్థల పర్వతాలు ఉన్నాయి);

• పాఠశాల-విద్యార్థుల చేతిపనులు ఉన్నాయి, కొన్ని తెలియని కారణాల వల్ల, అప్‌స్ట్రీమ్ PyPIలో ముగుస్తుంది మరియు కొత్త ప్యాకేజీల పేర్లతో మాత్రమే సమస్యలను సృష్టిస్తుంది (ముఖ్యంగా, "స్మార్ట్-ఎన్వి" అనే పేరు అవసరమైన కొలత).

మరియు ఈ జాబితా చాలా కాలం పాటు కొనసాగవచ్చు. ఏది ఏమైనప్పటికీ, అనుకూలమైన మరియు సార్వత్రికమైనదాన్ని చేయాలనే ఆలోచన గురించి నన్ను ఉత్తేజపరిచేందుకు పై పాయింట్లు సరిపోతాయి.

Smart-env వ్రాయడానికి ముందు సెట్ చేయబడిన అవసరాలు:

• అత్యంత సాధారణ వినియోగ పథకం
• సులభంగా కాన్ఫిగర్ చేయగల డేటా టైపింగ్ మద్దతు
• పైథాన్ 2.7 అనుకూలమైనది
• పరీక్షల ద్వారా మంచి కోడ్ కవరేజ్

చివరికి ఇదంతా సాక్షాత్కరించింది. ఉపయోగం యొక్క ఉదాహరణ ఇక్కడ ఉంది:

from smart_env import ENV

print(ENV.HOME)  # Equals print(os.environ['HOME'])

# assuming you set env variable MYVAR to "True"

ENV.enable_automatic_type_cast()

my_var = ENV.MY_VAR  # Equals boolean True

ENV.NEW_VAR = 100  # Sets a new environment variable

మీరు ఉదాహరణ నుండి చూడగలిగినట్లుగా, కొత్త తరగతితో పని చేయడానికి, మీరు దానిని దిగుమతి చేసుకోవాలి (మీరు ఒక ఉదాహరణను సృష్టించాల్సిన అవసరం లేదు - అదనపు చర్యను తీసివేయండి). ఏదైనా ఎన్విరాన్‌మెంట్ వేరియబుల్‌కు యాక్సెస్ అనేది ENV క్లాస్ యొక్క వేరియబుల్‌గా సూచించడం ద్వారా సాధించబడుతుంది, ఇది వాస్తవానికి, ఈ తరగతిని స్థానిక సిస్టమ్ పర్యావరణానికి సహజమైన రేపర్‌గా చేస్తుంది, అదే సమయంలో దాదాపు ఏ సిస్టమ్‌కైనా సాధ్యమయ్యే కాన్ఫిగరేషన్ వస్తువుగా మారుస్తుంది ( ఇదే విధమైన విధానం, ఉదాహరణకు, జంగోలో సాధించబడింది, అక్కడ మాత్రమే కాన్ఫిగరేషన్ ఆబ్జెక్ట్ సెట్టింగుల మాడ్యూల్/ప్యాకేజీగా ఉంటుంది).

స్వయంచాలక టైపింగ్ మద్దతు మోడ్‌ను ప్రారంభించడం/నిలిపివేయడం అనేది రెండు పద్ధతులను ఉపయోగించి సాధించబడుతుంది - enable_automatic_type_cast() మరియు disable_automatic_type_cast(). ఎన్విరాన్‌మెంట్ వేరియబుల్‌లో సీరియలైజ్ చేయబడిన JSON లాంటి వస్తువు లేదా కేవలం బూలియన్ స్థిరాంకం కూడా ఉంటే ఇది సౌకర్యవంతంగా ఉంటుంది (ఎన్విరాన్‌మెంట్ వేరియబుల్‌ను “చెల్లుబాటు అయ్యే” స్ట్రింగ్‌లతో పోల్చడం ద్వారా జంగోలో డీబగ్ వేరియబుల్‌ను స్పష్టంగా సెట్ చేయడం అత్యంత సాధారణ సందర్భాలలో ఒకటి). కానీ ఇప్పుడు స్ట్రింగ్‌లను స్పష్టంగా మార్చాల్సిన అవసరం లేదు - అవసరమైన చాలా చర్యలు ఇప్పటికే లైబ్రరీ యొక్క లోతులలో పొందుపరచబడ్డాయి మరియు పని చేయడానికి సిగ్నల్ కోసం వేచి ఉన్నాయి. 🙂 సాధారణంగా, టైపింగ్ పారదర్శకంగా పని చేస్తుంది మరియు అందుబాటులో ఉన్న దాదాపు అన్ని అంతర్నిర్మిత డేటా రకాలకు మద్దతు ఇస్తుంది (ఫ్రోజెన్‌సెట్, కాంప్లెక్స్ మరియు బైట్‌లు పరీక్షించబడలేదు).

పైథాన్ 2కి మద్దతు ఇవ్వాల్సిన అవసరం వాస్తవంగా ఎటువంటి త్యాగాలు లేకుండా అమలు చేయబడింది (టైపింగ్ వదిలివేయడం మరియు పైథాన్ 3 యొక్క తాజా వెర్షన్‌ల యొక్క కొన్ని “షుగర్ క్యాండీలు”), ప్రత్యేకించి, సర్వవ్యాప్తి చెందిన ఆరు (మెటాక్లాస్‌లను ఉపయోగించడంలో సమస్యలను పరిష్కరించడానికి ధన్యవాదాలు) )

కానీ కొన్ని పరిమితులు ఉన్నాయి:

• పైథాన్ 3 సపోర్ట్ అంటే వెర్షన్ 3.5 మరియు అంతకంటే ఎక్కువ (మీ ప్రాజెక్ట్‌లో వారి ఉనికి సోమరితనం లేదా మెరుగుదలల అవసరం లేకపోవటం వల్ల ఏర్పడుతుంది, ఎందుకంటే మీరు ఇప్పటికీ 3.4లో ఎందుకు ఉన్నారనే నిష్పాక్షిక కారణాన్ని కనుగొనడం కష్టం);
• పైథాన్ 2.7లో, లైబ్రరీ సెట్ లిటరల్స్ యొక్క డీరియలైజేషన్‌కు మద్దతు ఇవ్వదు. వివరణ ఇక్కడ. కానీ ఎవరైనా దీన్ని అమలు చేయాలనుకుంటే, మీకు స్వాగతం :);

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

పైథాన్-షెల్ లైబ్రరీ

ఇప్పుడు నేను మీకు రెండవ లైబ్రరీ గురించి చెబుతాను (ఇప్పటికే ఉన్న అనలాగ్‌ల లోపాల వివరణను నేను విస్మరిస్తాను - ఇది స్మార్ట్-ఎన్‌వి. అనలాగ్‌ల కోసం వివరించిన మాదిరిగానే ఉంటుంది - ఇక్కడ и ఇక్కడ).

సాధారణంగా, అమలు ఆలోచన మరియు దాని అవసరాలు స్మార్ట్-ఎన్వి కోసం వివరించిన వాటికి సమానంగా ఉంటాయి, ఉదాహరణ నుండి చూడవచ్చు:

from python_shell import Shell

Shell.ls('-l', '$HOME')  # Equals "ls -l $HOME"

command = Shell.whoami()  # Equals "whoami"
print(command.output)  # prints your current user name

print(command.command)  # prints "whoami"
print(command.return_code)  # prints "0"
print(command.arguments)  # prints ""

Shell.mkdir('-p', '/tmp/new_folder')  # makes a new folder

ఆలోచన ఇది:

1. పైథాన్ ప్రపంచంలో బాష్‌ను సూచించే ఒకే తరగతి;
2. ప్రతి బాష్ కమాండ్ షెల్ క్లాస్ యొక్క విధిగా పిలువబడుతుంది;
3. ప్రతి ఫంక్షన్ కాల్ కోసం పారామితులు సంబంధిత బాష్ కమాండ్ కాల్‌కి పంపబడతాయి;
4. ప్రతి ఆదేశం "ఇక్కడ మరియు ఇప్పుడు" అని పిలువబడే సమయంలో అమలు చేయబడుతుంది, అనగా. సింక్రోనస్ విధానం పనిచేస్తుంది;
5. stdoutలో కమాండ్ యొక్క అవుట్‌పుట్‌ను అలాగే దాని రిటర్న్ కోడ్‌ను యాక్సెస్ చేయడం సాధ్యపడుతుంది;
6. కమాండ్ సిస్టమ్‌లో లేకుంటే, మినహాయింపు విసిరివేయబడుతుంది.

Smart-env మాదిరిగా, పైథాన్ 2కి మద్దతు ఉంది (కొంచెం ఎక్కువ త్యాగం చేసే రక్తం అవసరం అయినప్పటికీ) మరియు పైథాన్ 3.0-3.4కి మద్దతు లేదు.

గ్రంథాలయ అభివృద్ధి ప్రణాళికలు

మీరు ఇప్పుడు లైబ్రరీలను ఉపయోగించవచ్చు: రెండూ అధికారిక PyPIలో పోస్ట్ చేయబడ్డాయి. మూలాలు గితుబ్‌లో అందుబాటులో ఉన్నాయి (క్రింద చూడండి).

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

• నాన్-బ్లాకింగ్ కాల్‌లకు మద్దతు;
• బృందంతో ఇంటరాక్టివ్ కమ్యూనికేషన్ యొక్క అవకాశం (stdinతో పని చేయడం);
• కొత్త లక్షణాలను జోడించడం (ఉదాహరణకు, stderr నుండి అవుట్‌పుట్ స్వీకరించడానికి ఆస్తి);
• అందుబాటులో ఉన్న ఆదేశాల డైరెక్టరీని అమలు చేయడం (dir() ఫంక్షన్‌తో ఉపయోగం కోసం);
• మరియు అందువలన న.

సూచనలు

1. స్మార్ట్-ఎన్వి లైబ్రరీ: Github и PyPI
2. పైథాన్-షెల్ లైబ్రరీ: Github и PyPI
3. టెలిగ్రామ్ ఛానల్ లైబ్రరీ నవీకరణలు

UPD 23.02.2020/XNUMX/XNUMX:
* రిపోజిటరీలు తరలించబడ్డాయి, సంబంధిత లింక్‌లు నవీకరించబడ్డాయి
* python-shell==1.0.1 వెర్షన్ 29.02.2020/XNUMX/XNUMXన విడుదలకు సిద్ధమవుతోంది. మార్పులలో కమాండ్ స్వయంపూర్తి మరియు dir(Shell) కమాండ్‌కు మద్దతు, చెల్లని పైథాన్ ఐడెంటిఫైయర్‌తో కమాండ్‌లను అమలు చేయడం మరియు బగ్ పరిష్కారాలు ఉన్నాయి.

మూలం: www.habr.com