Marcel: लिनक्स के लिए एक आधुनिक, Python-संचालित शेल

Marcel एक नया शेल है। यह कई मायनों में पारंपरिक शेल्स के समान है, लेकिन यह कुछ चीजें अलग तरह से करता है:

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

Marcel GPLv3 के तहत लाइसेंस प्राप्त है।

लिनक्स में Marcel मॉडर्न शेल इंस्टॉल करना

Marcel को Python 3.6 या बाद के संस्करण की आवश्यकता होती है। इसे लिनक्स पर विकसित और परीक्षण किया गया है, और यह ज्यादातर macOS पर काम करता है। (यदि आप Windows पर पोर्ट करने में मदद करना चाहते हैं, या macOS की कमियों को ठीक करना चाहते हैं, तो संपर्क करें।)

marcel को अपने उपयोग के लिए इंस्टॉल करने के लिए:

# python3 -m pip install marcel

या यदि आप सभी उपयोगकर्ताओं के लिए इंस्टॉल करना चाहते हैं (उदाहरण के लिए, /usr/local पर):

$ sudo python3 -m pip install --prefix /usr/local marcel

एक बार जब आप marcel इंस्टॉल कर लेते हैं, तो marcel कमांड चलाकर जांचें कि यह काम कर रहा है, और फिर marcel प्रॉम्प्ट पर version कमांड चलाएं:

$ marcel

Marcel: लिनक्स के लिए एक आधुनिक, Python-संचालित शेल

Marcel शेल का अनुकूलन

आप ~/.marcel.py फ़ाइल में marcel को अनुकूलित कर सकते हैं, जिसे स्टार्टअप पर पढ़ा जाता है, (और जब संशोधित किया जाता है तो पुनः पढ़ा जाता है)। जैसा कि आप फ़ाइल के नाम से बता सकते हैं, marcel का अनुकूलन Python में किया जाता है।

एक चीज जो आप शायद करना चाहते हैं वह है प्रॉम्प्ट को अनुकूलित करना। ऐसा करने के लिए, आप PROMPT वेरिएबल को एक लिस्ट असाइन करते हैं। उदाहरण के लिए, यदि आप चाहते हैं कि आपका प्रॉम्प्ट वर्तमान डायरेक्टरी हो, जो हरे रंग में प्रिंट हो, उसके बाद > नीले रंग में प्रिंट हो:

PROMPT = [ Color(0, 4, 0), lambda: PWD, Color(0, 2, 5), '> ' ]

परिणामी प्रॉम्प्ट ऐसा दिखता है:

यह bash में आपको जो करना होता है उस रहस्यमय PS1 कॉन्फ़िगरेशन को बदल देता है। Color(0, 4, 0) हरा निर्दिष्ट करता है, (आर्गुमेंट्स RGB मान हैं, रेंज 0-5 में)। PWD आपके वर्तमान डायरेक्टरी को दर्शाने वाला एनवायरनमेंट वेरिएबल है और इस वेरिएबल को lambda: से प्रीफिक्स करने से एक फ़ंक्शन जनरेट होता है, जिसे हर बार प्रॉम्प्ट प्रदर्शित होने पर मूल्यांकन किया जाता है।

~/.marcel.py Python मॉड्यूल्स भी आयात कर सकता है। उदाहरण के लिए, यदि आप अपने marcel कमांड्स में math मॉड्यूल के फ़ंक्शंस का उपयोग करना चाहते हैं:

from math import *

एक बार जब आप यह कर लेते हैं, तो आप उस मॉड्यूल से सिंबल्स को संदर्भित कर सकते हैं, उदाहरण के लिए pi:

ध्यान दें कि pi पैरेंथेसाइज़्ड है। सामान्य तौर पर, marcel Python एक्सप्रेशन को डिलीमिट करने के लिए पैरेंथेसिस का उपयोग करता है। तो (pi) वेरिएबल pi का मान प्राप्त करने वाले Python एक्सप्रेशन का मूल्यांकन करता है। आप इसी तरह पारंपरिक एनवायरनमेंट वेरिएबल्स तक भी पहुंच सकते हैं, उदाहरण के लिए (USER) और (HOME), या marcel के नेमस्पेस में सिंबल्स पर निर्भर कोई भी वैध Python एक्सप्रेशन।

और आप निश्चित रूप से अपने स्वयं के सिंबल्स परिभाषित कर सकते हैं। उदाहरण के लिए, यदि आप इस फ़ंक्शन परिभाषा को ~/.marcel.py में डालते हैं:

def factorial(n):
  f = 1
  for i in range(1, n + 1):
    f *= i
  return f

तो आप कमांड लाइन पर factorial फ़ंक्शन का उपयोग कर सकते हैं, उदाहरण के लिए:

Marcel शेल उदाहरण

यहां, हम marcel शेल में कमांड्स के कुछ उदाहरण सीखेंगे।

एक्सटेंशन द्वारा फ़ाइल साइज़ खोजें

वर्तमान डायरेक्टरी को रिकर्सिवली एक्सप्लोर करें, फ़ाइलों को उनके एक्सटेंशन (जैसे .txt, .py आदि) द्वारा ग्रुप करें, और प्रत्येक ग्रुप के लिए कुल फ़ाइल साइज़ की गणना करें।

आप marcel में इसे इस तरह कर सकते हैं:

ls ऑपरेटर File ऑब्जेक्ट्स की एक स्ट्रीम उत्पन्न करता है, (-fr का अर्थ है डायरेक्टरीज को रिकर्सिवली विजिट करें, और केवल फ़ाइलें लौटाएं)।

File ऑब्जेक्ट्स को अगले कमांड, map पर पाइप किया जाता है। map एक Python फ़ंक्शन निर्दिष्ट करता है, सबसे बाहरी पैरेंथेसिस में, जो प्रत्येक फ़ाइल को टुपल में मैप करता है जिसमें फ़ाइल का एक्सटेंशन और उसका साइज़ होता है। (Marcel lambda कीवर्ड को छोड़ने की अनुमति देता है।)

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

होस्ट एक्जीक्यूटेबल्स और Marcel पाइपलाइन

पाइपलाइन्स में marcel ऑपरेटर्स और होस्ट एक्जीक्यूटेबल्स का मिश्रण हो सकता है। ऑपरेटर्स ऑब्जेक्ट्स पाइप करते हैं, लेकिन ऑपरेटर/एक्जीक्यूटेबल सीमाओं पर, marcel स्ट्रिंग्स पाइप करता है।

उदाहरण के लिए, यह कमांड ऑपरेटर्स और एक्जीक्यूटेबल्स को जोड़ती है और उन उपयोगकर्ताओं के उपयोगकर्ता नाम सूचीबद्ध करती है जिनका शेल /bin/bash है।

$ cat /etc/passwd \
 | map (line: line.split(':')) \
 | select (*line: line[-1] == '/bin/bash') \
 | map (*line: line[0]) \
 | xargs echo

cat एक लिनक्स एक्जीक्यूटेबल है। यह /etc/passwd पढ़ता है, और marcel इसकी सामग्री को डाउनस्ट्रीम marcel ऑपरेटर map पर पाइप करता है।

map का पैरेंथेसाइज़्ड आर्गुमेंट एक Python फ़ंक्शन है जो लाइन्स को : सेपरेटर्स पर विभाजित करता है, जिससे 7-टुपल्स प्राप्त होते हैं। एक select एक marcel ऑपरेटर है जिसका आर्गुमेंट एक Python फ़ंक्शन है जो उन टुपल्स की पहचान करता है जिनमें अंतिम फ़ील्ड /bin/bash है।

अगला ऑपरेटर, एक और map प्रत्येक इनपुट टुपल का यूज़रनेम फ़ील्ड रखता है। अंत में, xargs echo आने वाले यूज़रनेम को एक सिंगल लाइन में जोड़ता है, जिसे stdout पर प्रिंट किया जाता है।

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

जबकि Python को कभी-कभी स्क्रिप्टिंग भाषा माना जाता है, यह वास्तव में उस उद्देश्य के लिए अच्छी तरह से काम नहीं करता। समस्या यह है कि Python से शेल कमांड्स, और अन्य एक्जीक्यूटेबल्स चलाना बोझिल है। आप os.system() का उपयोग कर सकते हैं, जो सरल है लेकिन अक्सर stdin, stdout, और stderr से निपटने के लिए अपर्याप्त है। subprocess.Popen() अधिक शक्तिशाली है लेकिन उपयोग करने में अधिक जटिल है।

Marcel का दृष्टिकोण एक मॉड्यूल प्रदान करना है जो marcel ऑपरेटर्स को Python की भाषा सुविधाओं के साथ एकीकृत करता है। पहले के उदाहरण को दोहराने के लिए, यहां एक्सटेंशन द्वारा फ़ाइल साइज़ के योग की गणना करने के लिए Python कोड है:

from marcel.api import *
for ext, size in (ls(file=True, recursive=True) | map(lambda f: (f.suffix, f.size)) | red('.', '+')):
  print(f'{ext}: {size}')

शेल कमांड्स पहले जैसे ही हैं, सिंटैक्टिक कन्वेंशन के अलावा। तो ls -fr ls(file=True, recursive=True) में बदल जाता है। map और red ऑपरेटर्स भी वहां हैं, पाइप्स से जुड़े हुए, शेल वर्जन की तरह। पूरा शेल कमांड (ls ... red) एक Python इटरेटर देता है ताकि कमांड को Python के for लूप के साथ उपयोग किया जा सके।

Marcel शेल के साथ डेटाबेस एक्सेस

आप marcel पाइपलाइन्स के साथ डेटाबेस एक्सेस को एकीकृत कर सकते हैं। पहले, आपको कॉन्फ़िगर फ़ाइल, ~/.marcel.py में डेटाबेस एक्सेस कॉन्फ़िगर करने की आवश्यकता है, उदाहरण के लिए:

define_db(name='jao', driver='psycopg2', dbname='acme', user='jao')
DB_DEFAULT = 'jao'

यह psycopg2 ड्राइवर का उपयोग करके acme नामक एक Postgres डेटाबेस तक पहुंच कॉन्फ़िगर करता है। Marcel से कनेक्शन jao उपयोगकर्ता का उपयोग करके किए जाएंगे, और डेटाबेस प्रोफाइल का नाम jao है। (DB_DEFAULT jao डेटाबेस प्रोफाइल को निर्दिष्ट करता है जिसका उपयोग तब किया जाता है जब कोई प्रोफाइल निर्दिष्ट नहीं की जाती।) इस कॉन्फ़िगरेशन के साथ, डेटाबेस को अब sql ऑपरेटर का उपयोग करके क्वेरी किया जा सकता है, उदाहरण के लिए:

sql 'select part_name, quantity from part where quantity < 10' \
 | out --csv --file ~/reorder.csv

यह कमांड part नामक एक टेबल को क्वेरी करता है, और क्वेरी परिणाम को फ़ाइल ~/reorder.csv में CSV फॉर्मेट में डंप करता है।

Marcel शेल के साथ रिमोट एक्सेस

डेटाबेस एक्सेस के समान, रिमोट एक्सेस को ~/.marcel.py में कॉन्फ़िगर किया जा सकता है। उदाहरण के लिए, यह एक 4-नोड क्लस्टर कॉन्फ़िगर करता है:

define_remote(name='lab', user='frankenstein', identity='/home/frankenstein/.ssh/id_rsa', host=['10.0.0.100', '10.0.0.101', '10.0.0.102', '10.0.0.103'])

क्लस्टर को marcel कमांड्स में lab के रूप में पहचाना जा सकता है। यूजर और आइडेंटिटी पैरामीटर्स लॉगिन जानकारी निर्दिष्ट करते हैं, और होस्ट पैरामीटर क्लस्टर पर नोड्स के IP एड्रेस निर्दिष्ट करता है।

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

@lab [ps | map (proc: (proc.pid, proc.commandline))]

यह (IP एड्रेस, PID, कमांड लाइन) टुपल्स की एक स्ट्रीम लौटाता है।

अधिक जानकारी के लिए देखें:

Marcel काफी नया है और सक्रिय विकास के अधीन है। यदि आप मदद करना चाहें तो संपर्क करें।