मार्सेल - लिनक्स के लिए एक और आधुनिक शेल

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

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

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

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

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

मार्सेल स्थापित करने के लिए अपने स्वयं के उपयोग के लिए:

# python3 -m pip install marcel

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

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

एक बार जब आप मार्सेल . स्थापित कर लेते हैं , marcel . कमांड चलाकर जांचें कि यह काम कर रहा है या नहीं , और फिर मार्सेल . पर प्रॉम्प्ट, संस्करण चलाएँ आदेश:

$ marcel

मार्सेल शैल का अनुकूलन

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

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

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

परिणामी संकेत इस तरह दिखता है:

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

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

from math import *

एक बार ऐसा करने के बाद, आप उस मॉड्यूल के प्रतीकों का उल्लेख कर सकते हैं, उदा। pi :

ध्यान दें कि pi लघुकृत है। सामान्य तौर पर, मार्सेल पायथन अभिव्यक्तियों को सीमित करने के लिए कोष्ठक का उपयोग करता है। तो (pi) वेरिएबल pi . के मान को पुनः प्राप्त करने वाले पायथन एक्सप्रेशन का मूल्यांकन करता है . आप इस तरह से पारंपरिक पर्यावरण चर का भी उपयोग कर सकते हैं, उदा। (उपयोगकर्ता) और (होम) , या मार्सेल के नेमस्पेस में प्रतीकों पर निर्भर कोई मान्य पायथन अभिव्यक्ति।

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

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

तो आप कमांड लाइन पर फैक्टोरियल फ़ंक्शन का उपयोग कर सकते हैं, जैसे

मार्सेल शैल उदाहरण

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

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

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

आप इसे मार्सेल में इस प्रकार कर सकते हैं:

एलएस ऑपरेटर फ़ाइल ऑब्जेक्ट्स की एक स्ट्रीम उत्पन्न करता है, (-fr इसका मतलब है कि निर्देशिकाओं को बार-बार देखें, और केवल फाइलें लौटाएं)।

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

लाल (कम करें) ऑपरेटर, टपल के पहले भाग के अनुसार समूह (एक्सटेंशन ) और फिर प्रत्येक समूह के आकारों का योग करें। परिणाम एक्सटेंशन द्वारा क्रमबद्ध किया गया है।

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

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

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

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

बिल्ली एक लिनक्स निष्पादन योग्य है। यह पढ़ता है /etc/passwd , और मार्सेल अपनी सामग्री को मार्सेल ऑपरेटर मैप पर नीचे की ओर पाइप करता है।

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

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

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

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

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

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 . में बदल जाता है , पुनरावर्ती=सत्य) . मैप और रेड ऑपरेटर भी हैं, जो पाइप से जुड़े हैं, जैसा कि शेल संस्करण में है। संपूर्ण शेल कमांड (ls ... red) एक पायथन इटरेटर उत्पन्न करता है ताकि लूप के लिए पायथन के साथ कमांड का उपयोग किया जा सके।

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

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

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

DB_DEFAULT = 'jao'

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

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

यह आदेश भाग . नामक तालिका से पूछताछ करता है , और क्वेरी परिणाम को ~/reorder.csv . फ़ाइल में डंप करता है , सीएसवी प्रारूप में।

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

इसी तरह डेटाबेस एक्सेस के लिए, रिमोट एक्सेस को ~/.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'])

क्लस्टर को एक प्रयोगशाला . के रूप में पहचाना जा सकता है मार्सेल कमांड में। उपयोगकर्ता और पहचान पैरामीटर लॉगिन जानकारी और होस्ट . निर्दिष्ट करते हैं पैरामीटर क्लस्टर पर नोड्स के आईपी पते निर्दिष्ट करता है।

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

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

यह (आईपी पता, पीआईडी, कमांड लाइन) टुपल्स की एक धारा देता है।

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

• https://www.marceltheshell.org/
• https://github.com/geophile/marcel

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